Module Contents

AbstractCashFlow(progressTracker:

Module Contents

abstract class AbstractRequest

)

Module Contents

AbstractRequest(amount:

)

object FINALISING_TX :

protected fun finaliseTx(tx:

object GENERATING_TX :

Module Contents

recipient

)

sessions

message

)

abstract class AbstractCashSelection

Module Contents

AbstractCashSelection(maxRetries:

retrySleep

retryCap

protected abstract fun executeQuery(connection:

)

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

fun getInstance(metadata: () ->

)

val instance:

AtomicReference

protected abstract fun isCompatible(metadata:

)

abstract fun toString():

fun unconsumedCashStatesForSpending(services:

amount

@DoNotImplement abstract class AbstractParty :

onlyFromIssuerParties

notary

lockId

withIssuerRefs

)

Module Contents

AbstractParty(owningKey:

)

abstract fun nameOrNull():

)

val owningKey:

abstract fun ref(bytes:

)

fun ref(vararg bytes:

)

abstract class AbstractStateReplacementFlow

Module Contents

AbstractStateReplacementFlow()

abstract class Acceptor<in T> :

Module Contents

)

progressTracker

)

val initiatingSession:

protected abstract fun verifyProposal(stx:

proposal

Proposal

)

abstract class Instigator<out S :

out

out

Module Contents

Instigator(originalState:

protected abstract fun assembleTx():

modification

progressTracker

)

open fun getParticipantSessions():

data class Proposal<out M>

Module Contents

Proposal(stateRef:

enum class AccrualAdjustment

modification

)

Module Contents

)

Module Contents

Module Contents

serviceId

owningLegalIdentity

)

Module Contents

)

enum class AggregateFunctionType

owningLegalIdentity

)

Module Contents

interface AllPossibleRecipients :

object AlwaysAcceptAttachmentConstraint :

Module Contents

)

data class Amount<T :

Module Contents

Amount(tokenQuantity:

token

)

Amount(quantity:

displayTokenSize

token

)

fromDecimal

(

displayQuantity

token

rounding

RoundingMode

)

fun getDisplayTokenSize(token:

)

operator fun minus(other:

)

fun parseCurrency(input:

)

fun splitEvenly(partitions:

)

)

sumOrNull

(

)

sumOrThrow

(

)

sumOrZero

(

token

)

)

)

zero

(

token

)

class AmountTransfer<T :

AmountTransfer(quantityDelta:

Module Contents

token

source

destination

)

newRef

)

)

fromDecimal

(

displayQuantityDelta

token

source

destination

rounding

)

fun novate(centralParty:

)

)

zero

(

token

source

destination

)

class AnonymousParty :

AnonymousParty(owningKey:

Module Contents

)

)

interface AppServiceHub :

const val SERVICE_PRIORITY_HIGH:

Module Contents

const val SERVICE_PRIORITY_LOW:

const val SERVICE_PRIORITY_NORMAL:

abstract fun register(priority:

abstract val database:

CordaTransactionSupport

observer

ServiceLifecycleObserver

)

open fun <T> register(priority:

func

(

)

abstract fun <T> startFlow(flow:

)

abstract fun <T> startTrackedFlow(flow:

)

@DoNotImplement interface Attachment :

open fun extractFile(path:

Module Contents

outputTo

)

open fun openAsJAR():

JarInputStream

abstract val signerKeys:

@DoNotImplement interface AttachmentConstraint

abstract val ~~signers~~:

Module Contents

abstract fun isSatisfiedBy(attachment:

)

typealias AttachmentFixup = <ERROR CLASS><

typealias AttachmentId =

sealed class AttachmentQueryCriteria :

Module Contents

AndVisitor

Module Contents

AndComposition(a:

)

data class AttachmentsQueryCriteria :

Module Contents

filenameCondition

uploadDateCondition

)

)

filenameCondition

)

val contractClassNamesCondition:

filenameCondition

uploadDateCondition

contractClassNamesCondition

signersCondition

isSignedCondition

versionCondition

)

fun copy(uploaderCondition:

filenameCondition

uploadDateCondition

)

val filenameCondition:

fun isSigned(isSignedPredicate:

)

val isSignedCondition:

val signersCondition:

val uploadDateCondition:

val uploaderCondition:

val versionCondition:

fun visit(parser:

)

fun withContractClassNames(contractClassNamesPredicate:

)

fun withFilename(filenamePredicate:

)

fun withSigners(signersPredicate:

)

fun withUploadDate(uploadDatePredicate:

)

fun withUploader(uploaderPredicate:

)

fun withVersion(versionPredicate:

)

OrVisitor

Module Contents

OrComposition(a:

)

)

)

AttachmentResolutionException(hash:

Module Contents

)

AttachmentResolutionException(attachmentId:

Module Contents

data class AttachmentSort :

)

Module Contents

AttachmentSort(columns:

enum class AttachmentSortAttribute

)

Module Contents

data class AttachmentSortColumn

Module Contents

AttachmentSortColumn(sortAttribute:

direction

)

val columns:

@DoNotImplement interface AttachmentStorage

Module Contents

abstract fun getLatestContractAttachments(contractClassName:

minContractVersion

)

abstract fun hasAttachment(attachmentId:

)

abstract fun ~~importAttachment~~(jar:

)

abstract fun importAttachment(jar:

uploader

filename

)

abstract fun ~~importOrGetAttachment~~(jar:

)

)

abstract fun queryAttachments(criteria:

sorting

)

open fun queryAttachments(criteria:

)

interface AttachmentsQueryCriteriaParser :

Module Contents

)

@Target([AnnotationTarget.PROPERTY]) annotation class AutoAcceptable

data class AuthServiceId

Module Contents

)

Module Contents

AutoAcceptable()

object ~~AutomaticHashConstraint~~ :

Module Contents

)

object AutomaticPlaceholderConstraint :

Module Contents

)

interface BaseQueryCriteriaParser<Q :

abstract fun parse(criteria:

Module Contents

sorting

)

abstract fun parseAnd(left:

right

)

abstract fun parseOr(left:

right

)

@DoNotImplement abstract class BaseTransaction :

abstract class BaseSort

Module Contents

BaseSort()

Module Contents

BaseTransaction()

filterOutRefs

(

clazz

predicate

)

filterOutRefs

(

crossinline

predicate

(

)

)

filterOutputs

(

clazz

predicate

)

filterOutputs

(

crossinline

predicate

(

)

)

findOutRef

(

clazz

predicate

)

findOutRef

(

crossinline

predicate

(

)

)

findOutput

(

clazz

predicate

)

findOutput

(

crossinline

predicate

(

)

)

)

outRef

(

index

)

outRef

(

state

)

outRefsOfType

(

clazz

)

outRefsOfType

(

)

abstract val outputs:

outputsOfType

(

clazz

)

outputsOfType

(

)

@Target([AnnotationTarget.CLASS]) annotation class BelongsToContract

Module Contents

BelongsToContract(value:

out

)

out

data class BilateralNetState<P :

BilateralNetState(partyKeys:

Module Contents

template

)

interface BilateralNettableState<N :

abstract val bilateralNetState:

Module Contents

enum class BinaryComparisonOperator :

abstract fun net(other:

)

enum class BinaryLogicalOperator :

Module Contents

GREATER_THAN

GREATER_THAN_OR_EQUAL

LESS_THAN

LESS_THAN_OR_EQUAL

class BrokenAttachmentException :

Module Contents

AND

BrokenAttachmentException(attachmentId:

Module Contents

message

cause

)

Module Contents

avg

(

groupByColumns

orderBy

)

~~avg~~

(

groupByColumns

orderBy

)

avg

(

groupByColumns

orderBy

)

between

(

from

)

~~between~~

(

from

)

between

(

from

)

between

(

from

)

Between

compare

(

operator

value

)

comparePredicate

(

operator

value

)

~~comparePredicate~~

(

operator

value

)

comparePredicate

(

operator

value

)

count

(

)

~~count~~

(

)

count

(

)

equal

(

value

exactMatch

)

~~equal~~

(

value

exactMatch

)

equal

(

value

exactMatch

)

exactMatch

)

functionPredicate

(

predicate

groupByColumns

orderBy

)

~~functionPredicate~~

(

predicate

groupByColumns

orderBy

)

functionPredicate

(

predicate

groupByColumns

orderBy

)

greaterThan

(

value

)

~~greaterThan~~

(

value

)

greaterThan

(

value

)

greaterThan

(

value

)

greaterThanOrEqual

(

value

)

~~greaterThanOrEqual~~

(

value

)

greaterThanOrEqual

(

value

)

greaterThanOrEqual

(

value

)

(

collection

exactMatch

)

(

collection

exactMatch

)

(

collection

exactMatch

)

(

collection

exactMatch

)

isNull

(

)

~~isNull~~

(

)

isNull

(

)

lessThan

(

value

)

~~lessThan~~

(

value

)

lessThan

(

value

)

lessThan

(

value

)

lessThanOrEqual

(

value

)

~~lessThanOrEqual~~

(

value

)

lessThanOrEqual

(

value

)

lessThanOrEqual

(

value

)

exactMatch

)

(

string

exactMatch

)

~~like~~

(

string

exactMatch

)

(

string

exactMatch

)

max

(

groupByColumns

orderBy

)

~~max~~

(

groupByColumns

orderBy

)

max

(

groupByColumns

orderBy

)

min

(

groupByColumns

orderBy

)

~~min~~

(

groupByColumns

orderBy

)

min

(

groupByColumns

orderBy

)

notEqual

(

value

exactMatch

)

~~notEqual~~

(

value

exactMatch

)

notEqual

(

value

exactMatch

)

fun <R> notEqual(value:

exactMatch

)

notIn

(

collection

exactMatch

)

~~notIn~~

(

collection

exactMatch

)

notIn

(

collection

exactMatch

)

notIn

(

collection

exactMatch

)

exactMatch

)

notLike

(

string

exactMatch

)

~~notLike~~

(

string

exactMatch

)

notLike

(

string

exactMatch

)

notNull

(

)

~~notNull~~

(

)

notNull

(

)

predicate

(

predicate

)

~~predicate~~

(

predicate

)

predicate

(

predicate

)

sum

(

groupByColumns

orderBy

)

~~sum~~

(

groupByColumns

orderBy

)

sum

(

groupByColumns

orderBy

open class BusinessCalendar

)

Module Contents

BusinessCalendar(holidayDates:

)

open fun applyRollConvention(testDate:

dateRollConvention

DateRollConvention

)

fun calculateDaysBetween(startDate:

endDate

dcbYear

dcbDay

)

fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

endDate

periodOffset

)

)

fun getOffsetDate(startDate:

period

steps

)

open fun isWorkingDay(date:

)

fun moveBusinessDays(date:

direction

)

fun parseDateFromString(it:

)

sealed class ByteSequence :

)

Module Contents

open fun compareTo(other:

)

)

offset

size

)

)

end

)

fun subSequence(offset:

size

)

)

)

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

val exitKeys: <ERROR CLASS>

Module Contents

amount

owner

)

owner

)

)

infix fun issuedBy(party:

)

infix fun issuedBy(deposit:

)

infix fun ownedBy(owner:

)

infix fun withDeposit(deposit:

)

)

fun extractCommands(commands:

newOwner

)

fun deriveState(txState:

amount

owner

)

)

fun generateExitCommand(amount:

)

tokenDef

pennies

owner

notary

)

fun generateMoveCommand():

amount

owner

notary

)

)

class CashException :

Module Contents

CashException(message:

cause

@InitiatingFlow @StartableByRPC class CashExitFlow :

)

Module Contents

issuerRef

)

CashExitFlow(request:

)

issuerRef

progressTracker

)

Module Contents

issuerRef

)

@InitiatedBy(CashExitFlow) class CashExitResponderFlow :

CashExitResponderFlow(otherSide:

Module Contents

)

@StartableByRPC class CashIssueAndPaymentFlow :

Module Contents

CashIssueAndPaymentFlow(request:

issueRef

recipient

anonymous

notary

)

IssueAndPaymentRequest

)

class IssueAndPaymentRequest :

issueRef

recipient

anonymous

notary

progressTracker

)

IssueAndPaymentRequest(amount:

Module Contents

issueRef

recipient

notary

anonymous

)

val PAYING_RECIPIENT:

@StartableByRPC class CashIssueFlow :

Module Contents

issuerBankPartyRef

notary

)

CashIssueFlow(request:

IssueRequest

)

@StartableByRPC @InitiatingFlow open class CashPaymentFlow :

issuerBankPartyRef

notary

progressTracker

)

Module Contents

issueRef

notary

)

Module Contents

recipient

)

recipient

anonymous

)

recipient

anonymous

notary

)

CashPaymentFlow(request:

PaymentRequest

)

recipient

anonymous

progressTracker

issuerConstraint

notary

)

class PaymentRequest :

Module Contents

PaymentRequest(amount:

recipient

anonymous

issuerConstraint

notary

)

@InitiatedBy(CashPaymentFlow) class CashPaymentReceiverFlow :

CashPaymentReceiverFlow(otherSide:

Module Contents

)

object CashSchemaV1 :

Module Contents

PersistentCashState(owner:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

class CashSelectionH2Impl :

Module Contents

CashSelectionH2Impl()

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

class CashSelectionPostgreSQLImpl :

)

CashSelectionPostgreSQLImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

class CashSelectionSQLServerImpl :

)

CashSelectionSQLServerImpl()

Module Contents

val JDBC_DRIVER_NAME_REGEX: <ERROR CLASS>

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

)

Module Contents

amount

onlyFromParties

)

amount

ourIdentity

onlyFromParties

anonymous

)

payments

onlyFromParties

)

interface CheckpointCustomSerializer<OBJ, PROXY>

payments

ourIdentity

onlyFromParties

anonymous

)

Module Contents

)

)

abstract fun hasListed(type:

interface ClassWhitelist

Module Contents

)

data class ClientRpcSslOptions

interface ~~ClientRelevantError~~

Module Contents

ClientRpcSslOptions(trustStorePath:

trustStorePassword

trustStoreProvider

)

val trustStorePassword:

val trustStorePath:

val trustStoreProvider:

@DoNotImplement abstract class ClusterSpec

Module Contents

Module Contents

)

abstract val clusterSize:

class CollectSignatureFlow :

Module Contents

session

vararg

signingKeys

)

session

signingKeys

)

class CollectSignaturesFlow :

Module Contents

sessionsToCollectFrom

progressTracker

)

sessionsToCollectFrom

myOptionalKeys

progressTracker

)

val progressTracker:

val sessionsToCollectFrom:

enum class CollectionOperator :

Module Contents

class Column<O, out C>

Module Contents

)

)

)

declaringClass

)

sealed class ColumnPredicate<C>

Module Contents

data class AggregateFunction<C> :

Module Contents

AggregateFunction(type:

)

data class Between<C :

Between(rightFromLiteral:

Module Contents

rightToLiteral

)

val rightFromLiteral:

val rightToLiteral:

data class BinaryComparison<C :

BinaryComparison(operator:

Module Contents

rightLiteral

)

data class CollectionExpression<C> :

CollectionExpression(operator:

Module Contents

rightLiteral

)

data class EqualityComparison<C> :

EqualityComparison(operator:

Module Contents

rightLiteral

)

data class NullExpression<C> :

data class Likeness :

Module Contents

rightLiteral

)

Module Contents

NullExpression(operator:

)

data class CommandAndState

data class Command<T :

Module Contents

key

)

signers

)

Module Contents

CommandAndState(command:

ownableState

)

interface CommandData

data class CommandWithParties<out T :

CommandWithParties(signers:

Module Contents

signingParties

value

)

val signers:

val ~~signingParties~~:

val value:

class CommercialPaper :

Module Contents

CommercialPaper()

const val CP_PROGRAM_ID:

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

owner

faceValue

maturityDate

)

)

fun withFaceValue(newFaceValue:

Issued

fun withMaturityDate(newMaturityDate:

)

)

)

object CommercialPaperSchema

fun withOwner(newOwner:

)

)

object CommercialPaperSchemaV1 :

class PersistentCommercialPaperState :

Module Contents

PersistentCommercialPaperState(issuancePartyHash:

Module Contents

issuanceRef

ownerHash

maturity

faceValue

currency

faceValueIssuerPartyHash

faceValueIssuerRef

)

var faceValueIssuerPartyHash:

var faceValueIssuerRef:

var issuancePartyHash:

object CommercialPaperUtils

Module Contents

fun generateIssue(issuance:

faceValue

maturityDate

notary

)

paper

newOwner

)

fun generateRedeem(tx:

paper

services

ourIdentity

)

data class Commodity :

TokenizableAssetInfo

Module Contents

Commodity(commodityCode:

displayName

defaultFractionDigits

)

val commodityCode:

val defaultFractionDigits:

val displayName:

fun getInstance(commodityCode:

)

Commodity

object CommonSchema

object CommonSchemaV1 :

Module Contents

class FungibleState :

FungibleState(participants:

Module Contents

owner

quantity

issuer

issuerRef

)

Module Contents

_participants

)

LinearState(participants:

externalId

uuid

)

open class ComponentGroup

Module Contents

ComponentGroup(groupIndex:

components

)

enum class ComponentGroupEnum

Module Contents

class ComponentVisibilityException :

ComponentVisibilityException(id:

Module Contents

reason

)

Module Contents

Module Contents

weight

)

fun addKeys(vararg keys:

)

)

)

const val KEY_ALGORITHM:

data class NodeAndWeight :

Module Contents

weight

)

)

fun toASN1Primitive(): <ERROR CLASS>

)

fun getFormat(): <ERROR CLASS>

fun getInstance(encoded:

fun getInstance(asn1: <ERROR CLASS>):

)

fun hashCode():

fun isFulfilledBy(key:

fun isFulfilledBy(keysToCheck:

)

)

class CompositeKeyFactory :

KeyFactorySpi

Module Contents

CompositeKeyFactory()

protected fun engineGeneratePrivate(keySpec:

KeySpec

)

protected fun engineGeneratePublic(keySpec:

)

engineGetKeySpec

(

key

keySpec

protected fun engineTranslateKey(key:

)

)

class CompositeSignature :

Signature

Module Contents

CompositeSignature()

const val SIGNATURE_ALGORITHM:

data class State

Module Contents

State(buffer:

verifyKey

CompositeKey

)

val buffer:

fun engineVerify(sigBytes:

)

protected fun ~~engineGetParameter~~(param:

)

protected fun engineInitSign(privateKey:

)

protected fun engineInitVerify(publicKey:

)

protected fun ~~engineSetParameter~~(param:

value

)

protected fun engineSetParameter(params:

)

protected fun engineSign():

)

protected fun engineVerify(sigBytes:

off

len

)

)

fun getService(provider:

data class CompositeSignaturesWithKeys

)

Service

Module Contents

CompositeSignaturesWithKeys(sigs:

CompositeSignaturesWithKeys

)

val EMPTY:

open class ConnectionFailureException :

ConnectionFailureException(cause:

Module Contents

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class ConstructorForDeserialization

)

Module Contents

ConstructorForDeserialization()

enum class ContextPropertyKeys

Module Contents

SERIALIZERS

interface Contract

Module Contents

abstract fun verify(tx:

)

class ContractAttachment :

ContractAttachment(attachment:

Module Contents

contract

additionalContracts

uploader

)

val additionalContracts:

@CordaInternal fun create(attachment:

contract

additionalContracts

uploader

signerKeys

version

)

typealias ContractClassName =

abstract val participants:

interface ContractState

Module Contents

data class ContractUpgradeFilteredTransaction :

ContractUpgradeFilteredTransaction(visibleComponents:

Module Contents

hiddenComponents

)

ContractUpgradeFilteredTransaction(visibleComponents:

hiddenComponents

digestService

)

class FilteredComponent

Module Contents

FilteredComponent(component:

nonce

)

fun copy(visibleComponents:

hiddenComponents

)

val digestService:

DigestService

val hiddenComponents:

val visibleComponents:

object ContractUpgradeFlow

FilteredComponent

Module Contents

@StartableByRPC class Authorise :

Module Contents

Authorise(stateAndRef:

@StartableByRPC class Deauthorise :

upgradedContractClass

out

)

@InitiatingFlow @StartableByRPC class Initiate<OldState :

Module Contents

Deauthorise(stateRef:

)

out

NewState

out

Module Contents

Initiate(originalState:

newContractClass

out

)

class ContractUpgradeLedgerTransaction :

ContractUpgradeLedgerTransaction(inputs:

Module Contents

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

)

val legacyContractAttachment:

)

val upgradedContractAttachment:

@DoNotImplement interface ContractUpgradeService

Module Contents

abstract fun getAuthorisedContractUpgrade(ref:

)

abstract fun removeAuthorisedContractUpgrade(ref:

)

abstract fun storeAuthorisedContractUpgrade(ref:

upgradedContractClass

out

UpgradedContract

)

data class ContractUpgradeWireTransaction :

ContractUpgradeWireTransaction(serializedComponents:

Module Contents

privacySalt

ContractUpgradeWireTransaction(serializedComponents:

)

privacySalt

digestService

)

Module Contents

fun buildFilteredTransaction():

privacySalt

ContractUpgradeWireTransaction

)

val legacyContractAttachmentId:

sigs

)

val upgradedContractAttachmentId:

open class CordaException :

Module Contents

cause

)

)

)

)

)

)

interface CordaFuture<V> :

abstract fun <W> then(callback: (

Module Contents

)

abstract fun toCompletableFuture():

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS]) annotation class CordaInternal

Module Contents

CordaInternal()

object CordaOID

Module Contents

const val ALIAS_PRIVATE_KEY:

const val CORDA_PLATFORM:

const val R3_ROOT:

const val X509_EXTENSION_CORDA_ROLE:

object CordaObjectIdentifier

Module Contents

val COMPOSITE_KEY: <ERROR CLASS>

val COMPOSITE_SIGNATURE: <ERROR CLASS>

class CordaRPCClient

Module Contents

configuration

)

configuration

classLoader

)

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

customSerializers

)

configuration

sslConfiguration

classLoader

customSerializers

@CordaInternal @VisibleForTesting fun getRegisteredCustomSerializers():

)

inline fun <A> use(username:

password

gracefulReconnect

)

password

targetLegalIdentity

gracefulReconnect

)

password

externalTrace

impersonatedActor

gracefulReconnect

)

password

externalTrace

impersonatedActor

targetLegalIdentity

gracefulReconnect

)

password

open class CordaRPCClientConfiguration

block

(

CordaRPCConnection

)

Module Contents

CordaRPCClientConfiguration(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

)

val DEFAULT:

operator fun ~~component1~~():

open val connectionMaxRetryInterval:

open val connectionRetryInterval:

open val connectionRetryIntervalMultiplier:

open val deduplicationCacheExpiry:

)

open val maxFileSize:

open val maxReconnectAttempts:

open val minimumServerProtocolVersion:

open val observationExecutorPoolSize:

open val reapInterval:

open val trackRpcCallSites:

class CordaRPCConnection :

Module Contents

fun notifyServerAndClose():

val proxy:

val serverProtocolVersion:

interface CordaRPCOps :

abstract fun acceptNewNetworkParameters(parametersHash:

Module Contents

)

abstract fun addVaultTransactionNote(txnId:

txnNote

)

abstract fun attachmentExists(id:

)

abstract fun currentNodeTime():

abstract fun finishedFlowsWithClientIds():

abstract fun finishedFlowsWithClientIdsAsAdmin():

abstract fun getVaultTransactionNotes(txnId:

)

abstract fun isFlowsDrainingModeEnabled():

abstract fun isWaitingForShutdown():

abstract fun killFlow(id:

)

@RPCReturnsObservables abstract fun networkMapFeed():

abstract fun networkMapSnapshot():

@RPCReturnsObservables abstract fun networkParametersFeed():

abstract fun nodeDiagnosticInfo():

ParametersUpdateInfo

NodeDiagnosticInfo

abstract fun nodeInfo():

)

abstract fun notaryIdentities():

abstract fun notaryPartyFromX500Name(x500Name:

)

)

exactMatch

)

)

abstract fun queryAttachments(query:

sorting

)

@RPCReturnsObservables abstract fun <T> reattachFlowWithClientId(clientId:

)

abstract fun refreshNetworkMapCache():

abstract fun registeredFlows():

abstract fun removeClientId(clientId:

)

abstract fun removeClientIdAsAdmin(clientId:

)

abstract fun setFlowsDrainingModeEnabled(enabled:

)

abstract fun shutdown():

@RPCReturnsObservables abstract fun <T> startFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startFlowDynamicWithClientId(clientId:

logicType

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startTrackedFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMappingFeed():

abstract fun stateMachineRecordedTransactionMappingSnapshot():

@RPCReturnsObservables abstract fun stateMachinesFeed():

abstract fun stateMachinesSnapshot():

abstract fun terminate(drainPendingFlows:

)

abstract fun uploadAttachment(jar:

)

abstract fun uploadAttachmentWithMetadata(jar:

uploader

filename

)

vaultQuery

(

contractStateType

out

)

vaultQueryBy

(

criteria

paging

sorting

contractStateType

out

)

vaultQueryByCriteria

(

criteria

contractStateType

out

)

vaultQueryByWithPagingSpec

(

contractStateType

out

criteria

paging

)

vaultQueryByWithSorting

(

contractStateType

out

criteria

sorting

)

vaultTrack

(

contractStateType

out

)

vaultTrackBy

(

criteria

paging

sorting

contractStateType

out

)

vaultTrackByCriteria

(

contractStateType

out

criteria

)

vaultTrackByWithPagingSpec

(

contractStateType

out

criteria

paging

)

vaultTrackByWithSorting

(

contractStateType

@RPCReturnsObservables abstract fun waitUntilNetworkReady():

out

criteria

sorting

)

abstract fun wellKnownPartyFromAnonymous(party:

)

abstract fun wellKnownPartyFromX500Name(x500Name:

)

open class CordaRuntimeException :

RuntimeException

Module Contents

cause

)

CordaRuntimeException(originalExceptionClassName:

)

_message

_cause

)

)

)

)

)

class CordaSecurityProvider :

@Target([AnnotationTarget.CLASS]) @Inherited annotation class CordaSerializable

Module Contents

CordaSecurityProvider()

const val PROVIDER_NAME:

algorithm

)

Module Contents

CordaSerializable()

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefault

Module Contents

CordaSerializationTransformEnumDefault(new:

old

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefaults

Module Contents

CordaSerializationTransformEnumDefaults(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRename

Module Contents

CordaSerializationTransformRename(to:

from

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRenames

Module Contents

CordaSerializationTransformRenames(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaService

Module Contents

CordaService()

class CordaServiceCriticalFailureException :

Module Contents

)

cause

abstract fun addSuppressed(suppressed:

)

interface CordaThrowable

Module Contents

)

abstract var originalExceptionClassName:

abstract val originalMessage:

abstract fun setCause(cause:

)

abstract fun setMessage(message:

)

@DoNotImplement interface CordaTransactionSupport

Module Contents

abstract fun <T> transaction(statement:

SessionScope

(

)

data class CordaX500Name

Module Contents

CordaX500Name(organisation:

organisation

locality

country

)

locality

country

)

organisationUnit

organisation

locality

state

country

)

const val ~~LENGTH_COUNTRY~~:

const val MAX_LENGTH_COMMON_NAME:

const val MAX_LENGTH_LOCALITY:

const val MAX_LENGTH_ORGANISATION:

const val MAX_LENGTH_ORGANISATION_UNIT:

const val MAX_LENGTH_STATE:

)

val organisationUnit:

)

@DoNotImplement interface Cordapp

Module Contents

@DoNotImplement interface Info

Module Contents

data class Contract :

Module Contents

vendor

versionId

licence

)

data class ContractAndWorkflow :

Info

Module Contents

ContractAndWorkflow(contract:

workflow

)

Module Contents

vendor

version

licence

)

data class Workflow :

Module Contents

vendor

versionId

licence

)

abstract fun hasUnknownFields():

abstract val licence:

abstract val shortName:

abstract val vendor:

abstract val version:

abstract val allFlows:

out

abstract val checkpointCustomSerializers:

CheckpointCustomSerializer

abstract val contractClassNames:

abstract val cordappClasses:

abstract val customSchemas:

abstract val initiatedFlows:

out

abstract val jarHash:

abstract val jarPath:

abstract val minimumPlatformVersion:

abstract val name:

abstract val rpcFlows:

out

abstract val schedulableFlows:

out

abstract val serializationCustomSerializers:

abstract val serializationWhitelists:

abstract val serviceFlows:

SerializationWhitelist

out

out

abstract val targetPlatformVersion:

@DoNotImplement interface CordappConfig

Module Contents

abstract fun exists(path:

)

abstract fun get(path:

)

abstract fun getBoolean(path:

)

abstract fun getDouble(path:

)

abstract fun getFloat(path:

abstract fun getInt(path:

)

Float

)

abstract fun getLong(path:

)

abstract fun getNumber(path:

abstract fun getString(path:

)

Number

)

class CordappConfigException :

CordappConfigException(msg:

Module Contents

@CordaInternal fun create(cordapp:

)

class CordappContext

Module Contents

CordappContext(cordapp:

attachmentId

classLoader

)

attachmentId

classLoader

config

)

data class CordappInfo

Module Contents

name

shortName

minimumPlatformVersion

targetPlatformVersion

version

vendor

licence

jarHash

)

val targetPlatformVersion:

@DoNotImplement interface CordappProvider

Module Contents

abstract fun getAppContext():

abstract fun getContractAttachmentID(contractClassName:

)

abstract class CoreTransaction :

Module Contents

abstract val networkParametersHash:

class CouldNotStartFlowException :

CouldNotStartFlowException(cause:

Module Contents

sealed class CriteriaExpression<O, out T>

)

Module Contents

data class AggregateFunctionExpression<O, C> :

AggregateFunctionExpression(column:

Module Contents

predicate

groupByColumns

orderBy

)

data class BinaryLogical<O> :

Module Contents

right

operator

)

val right:

data class ColumnPredicateExpression<O, C> :

ColumnPredicateExpression(column:

Module Contents

predicate

)

Module Contents

)

Module Contents

val DEFAULT_SIGNATURE_SCHEME:

val ECDSA_SECP256K1_SHA256:

val ECDSA_SECP256R1_SHA256:

val EDDSA_ED25519_SHA512:

val RSA_SHA256:

val SHA512_256: <ERROR CLASS>

val SPHINCS256_SHA256:

fun decodePrivateKey(encodedKey:

)

fun decodePrivateKey(schemeCodeName:

encodedKey

)

fun decodePrivateKey(signatureScheme:

encodedKey

)

fun decodePublicKey(encodedKey:

)

fun decodePublicKey(schemeCodeName:

encodedKey

)

fun decodePublicKey(signatureScheme:

encodedKey

)

fun deriveKeyPair(signatureScheme:

privateKey

seed

)

fun deriveKeyPair(privateKey:

seed

)

fun deriveKeyPairFromEntropy(signatureScheme:

entropy

)

fun deriveKeyPairFromEntropy(entropy:

)

fun doSign(privateKey:

clearData

)

fun doSign(schemeCodeName:

privateKey

clearData

)

fun doSign(signatureScheme:

privateKey

clearData

)

signableData

)

fun doVerify(schemeCodeName:

publicKey

signatureData

clearData

)

fun doVerify(publicKey:

signatureData

clearData

)

fun doVerify(signatureScheme:

publicKey

signatureData

clearData

)

transactionSignature

)

fun findProvider(name:

)

fun findSignatureScheme(algorithm: <ERROR CLASS>):

fun findSignatureScheme(schemeNumberID:

)

fun findSignatureScheme(schemeCodeName:

)

)

)

fun generateKeyPair(schemeCodeName:

)

fun generateKeyPair(signatureScheme:

)

fun isSupportedSignatureScheme(signatureScheme:

)

transactionSignature

)

fun isValid(publicKey:

signatureData

clearData

)

fun isValid(signatureScheme:

publicKey

signatureData

clearData

)

fun publicKeyOnCurve(signatureScheme:

publicKey

)

fun registerProviders():

fun supportedSignatureSchemes():

fun toSupportedPrivateKey(key:

)

fun toSupportedPublicKey(key: <ERROR CLASS>):

fun toSupportedPublicKey(key:

)

fun validatePublicKey(key:

)

interface CustomSerializationScheme

Module Contents

deserialize

(

bytes

clazz

context

abstract fun getSchemeId():

)

serialize

(

obj

context

)

data class DataFeed<out A, B>

Module Contents

DataFeed(snapshot:

updates

)

val snapshot:

val updates: <ERROR CLASS><

open class DataVendingFlow :

DataVendingFlow(otherSideSession:

Module Contents

payload

)

val payload:

protected open fun sendPayloadAndReceiveDataRequest(otherSideSession:

payload

)

protected open fun verifyDataRequest(dataRequest: Data):

Request

fun copyDatabaseSnapshot(baseDirectory:

object DatabaseSnapshot

Module Contents

)

fun databaseFilename(baseDirectory:

)

enum class DateRollConvention

Module Contents

enum class DateRollDirection

Module Contents

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

@Target([AnnotationTarget.FILE, AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.TYPEALIAS]) @CordaInternal annotation class DeleteForDJVM

Module Contents

DeleteForDJVM()

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class DeprecatedConstructorForDeserialization

Module Contents

DeprecatedConstructorForDeserialization(version:

)

@DoNotImplement interface Destination

@DoNotImplement interface DiagnosticsService

Module Contents

abstract fun nodeVersionInfo():

NodeVersionInfo

interface DigestAlgorithm

Module Contents

abstract val algorithm:

open fun componentDigest(bytes:

)

abstract fun digest(bytes:

)

abstract val digestLength:

open fun nonceDigest(bytes:

)

DigestService(hashAlgorithm:

data class DigestService

Module Contents

)

val allOnesHash:

fun componentHash(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun componentHash(nonce:

opaqueBytes

)

fun computeNonce(privacySalt:

groupIndex

internalIndex

)

)

)

serializedHash

(

)

open class DigitalSignature :

interface DirectStatePersistable :

Module Contents

DigitalSignature(bytes:

)

Module Contents

bytes

)

)

)

)

Module Contents

abstract val stateRef:

@Target([AnnotationTarget.CLASS]) @Inherited annotation class DoNotImplement

Module Contents

DoNotImplement()

class DoubleSpentInputs :

Module Contents

DoubleSpentInputs(ids:

@DoNotImplement interface DriverDSL

)

Module Contents

abstract fun baseDirectory(nodeName:

)

open val defaultNotaryHandle:

open val defaultNotaryIdentity:

open val defaultNotaryNode:

abstract val notaryHandles:

open fun startNode():

abstract fun startNode(parameters:

)

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

logLevelOverride

)

open fun startWebserver(handle:

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

)

abstract fun startWebserver(handle:

WebserverHandle

maximumHeapSize

)

data class DriverParameters

Module Contents

DriverParameters(cordappsForAllNodes:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

val allowHibernateToManageAppSchema:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

)

val debugPortAllocation:

val environmentVariables:

val djvmBootstrapSource:

val ~~extraCordappPackagesToScan~~:

val notaryCustomOverrides:

val premigrateH2Database:

val startNodesInProcess:

val waitForAllNodesToFinish:

val systemProperties:

fun withAllowHibernateToManageAppSchema(value:

)

)

fun withDebugPortAllocation(debugPortAllocation:

)

fun withDjvmBootstrapSource(djvmBootstrapSource:

)

fun withDjvmCordaSource(djvmCordaSource:

)

fun withDriverDirectory(driverDirectory:

)

fun withEnvironmentVariables(variables:

)

fun ~~withExtraCordappPackagesToScan~~(extraCordappPackagesToScan:

)

fun withInMemoryDB(inMemoryDB:

)

fun withIsDebug(isDebug:

)

fun withJmxPolicy(jmxPolicy:

)

)

fun withNotaryCustomOverrides(notaryCustomOverrides:

)

)

fun withPortAllocation(portAllocation:

)

fun withStartNodesInProcess(startNodesInProcess:

)

fun withSystemProperties(systemProperties:

)

fun withUseTestClock(useTestClock:

)

fun withWaitForAllNodesToFinish(waitForAllNodesToFinish:

)

object DummySecureRandom :

SecureRandom

class DuplicateOutputLabel :

DuplicateOutputLabel(label:

Module Contents

@DoNotImplement interface EncodingWhitelist

)

Module Contents

abstract fun acceptEncoding(encoding:

)

@DoNotImplement sealed class EnforceVerifyOrFail

enum class EqualityComparisonOperator :

Module Contents

NOT_EQUAL_IGNORE_CASE

data class Expression

Module Contents

)

Module Contents

data class FilteredComponentGroup :

FilteredComponentGroup(groupIndex:

Module Contents

components

nonces

partialMerkleTree

)

class FilteredTransaction :

fun buildFilteredTransaction(wtx:

Module Contents

filtering

)

fun checkAllComponentsVisible(componentGroupEnum:

ComponentGroupEnum

)

fun checkCommandVisibility(publicKey:

)

fun checkWithFun(checkingFun: (

)

)

val filteredComponentGroups:

class FilteredTransactionVerificationException :

FilteredComponentGroup

FilteredTransactionVerificationException(id:

Module Contents

reason

)

@InitiatingFlow class FinalityFlow :

Module Contents

extraRecipients

progressTracker

)

extraRecipients

)

)

progressTracker

)

firstSession

vararg

restSessions

)

sessions

progressTracker

)

sessions

statesToRecord

progressTracker

)

sessions

oldParticipants

progressTracker

)

object BROADCASTING :

@CordaInternal data class ExtraConstructorArgs

Module Contents

ExtraConstructorArgs(oldParticipants:

sessions

newApi

statesToRecord

)

Module Contents

@CordaInternal fun getExtraConstructorArgs():

Module Contents

value

)

Module Contents

forDay

ofTenor

)

interface FixableDealState :

abstract fun generateFix(ptx:

Module Contents

oldState

fix

)

abstract fun nextFixingOf():

FixOf

abstract val oracle:

open class FlowException :

Module Contents

cause

)

)

)

cause

originalErrorId

)

open fun getErrorId():

var originalErrorId:

interface FlowExternalAsyncOperation<R :

Module Contents

)

interface FlowExternalOperation<R :

Module Contents

@DoNotImplement interface FlowHandle<A> :

)

Module Contents

abstract val returnValue:

data class FlowHandleImpl<A> :

Module Contents

returnValue

)

interface FlowHandleWithClientId<A> :

Module Contents

abstract val clientId:

data class FlowHandleWithClientIdImpl<A> :

FlowHandleWithClientIdImpl(id:

Module Contents

returnValue

clientId

)

Module Contents

FlowInfo(flowVersion:

appName

)

sealed class FlowInitiator :

Module Contents

Module Contents

)

Module Contents

)

FlowInitiator

Module Contents

)

Module Contents

)

fun getName():

Module Contents

abstract class FlowLogic<out T>

Module Contents

FlowLogic()

FlowExternalAsyncOperation

await

(

operation

)

fun checkFlowIsNotKilled():

await

(

operation

FlowExternalOperation

)

abstract fun call():

fun checkFlowIsNotKilled(lazyMessage: () ->

)

fun checkFlowPermission(permissionName:

extraAuditData

)

)

fun flowStackSnapshot():

FlowStackSnapshot

fun ~~getFlowInfo~~(otherParty:

)

fun initiateFlow(destination:

)

val logger: <ERROR CLASS>

fun initiateFlow(party:

)

val ourIdentity:

val ourIdentityAndCert:

fun persistFlowStackSnapshot():

open fun receiveAllMap(sessions:

~~receive~~

(

otherParty

)

~~receive~~

(

receiveType

otherParty

)

receiveAll

(

receiveType

sessions

maySkipCheckpoint

)

out

maySkipCheckpoint

)

fun recordAuditEvent(eventType:

comment

extraAuditData

)

open fun ~~send~~(otherParty:

payload

)

sessions

maySkipCheckpoint

)

fun sendAllMap(payloadsPerSession:

maySkipCheckpoint

)

open fun <R> subFlow(subLogic:

~~sendAndReceive~~

(

otherParty

payload

)

~~sendAndReceive~~

(

receiveType

otherParty

payload

)

maySkipCheckpoint

)

)

fun trackStepsTree():

fun trackStepsTreeIndex():

fun waitForLedgerCommit(hash:

maySkipCheckpoint

)

fun waitForStateConsumption(stateRefs:

)

@DoNotImplement interface FlowLogicRef

@DoNotImplement interface FlowLogicRefFactory

Module Contents

abstract fun create(flowClass:

out

vararg

args

)

abstract fun create(flowClassName:

vararg

args

)

abstract fun toFlowLogic(ref:

)

interface FlowProgressHandle<A> :

Module Contents

abstract val progress: <ERROR CLASS><

abstract val stepsTreeFeed:

abstract val stepsTreeIndexFeed:

data class FlowProgressHandleImpl<A> :

FlowProgressHandleImpl(id:

Module Contents

returnValue

progress

stepsTreeIndexFeed

stepsTreeFeed

)

returnValue

progress

)

FlowProgressHandleImpl

val progress: <ERROR CLASS><

val stepsTreeIndexFeed:

@DoNotImplement abstract class FlowSession

Module Contents

FlowSession()

abstract val counterparty:

abstract val destination:

abstract fun getCounterpartyFlowInfo(maySkipCheckpoint:

)

abstract fun getCounterpartyFlowInfo():

receive

(

)

abstract fun <R :

receive

(

receiveType

maySkipCheckpoint

)

receive

(

receiveType

)

maySkipCheckpoint

)

)

sendAndReceive

(

payload

)

sendAndReceive

(

receiveType

payload

maySkipCheckpoint

)

sendAndReceive

(

receiveType

payload

)

data class FlowStackSnapshot

Module Contents

FlowStackSnapshot(time:

flowClass

stackFrames

)

Module Contents

Frame(stackTraceElement:

stackObjects

)

val stackTraceElement:

Module Contents

val annualCompoundCount:

(

)

abstract class FullTransaction :

Module Contents

FullTransaction()

protected fun checkNotaryWhitelisted():

interface FungibleAsset<T :

Module Contents

abstract val exitKeys:

abstract fun withNewOwnerAndAmount(newAmount:

newOwner

)

interface FungibleState<T :

Module Contents

interface GenericQueryCriteria<Q :

interface ChainableQueryCriteria<Q :

Module Contents

Module Contents

interface AndVisitor<Q :

Module Contents

)

interface OrVisitor<Q :

Module Contents

)

abstract infix fun and(criteria:

)

abstract infix fun or(criteria:

)

abstract fun visit(parser:

)

GracefulReconnect(onDisconnect:

class GracefulReconnect

Module Contents

onReconnect

maxAttempts

GracefulReconnect(onDisconnect: () ->

)

onReconnect

(

)

maxAttempts

)

val onDisconnect: () ->

val onReconnect: () ->

data class HashAttachmentConstraint :

HashAttachmentConstraint(attachmentId:

Module Contents

)

val attachmentId:

val disableHashConstraints:

)

open class HospitalizeFlowException :

Module Contents

HospitalizeFlowException(cause:

)

HospitalizeFlowException()

)

fun fromHostAndPort(hostAndPort:

cause

)

Module Contents

mapper

)

base

protocol

mapper

)

HttpApi

getJson

(

path

params

val mapper: <ERROR CLASS>

)

data

)

data

)

data

)

Module Contents

val defaultMapper: <ERROR CLASS>

getJson

(

url

params

@DoNotImplement interface IQueryCriteriaParser :

mapper

)

data

)

data

)

data

)

Sort

Module Contents

)

)

)

abstract fun <L :

parseCriteria

(

criteria

)

)

open class Id<out VALUE :

Module Contents

entityType

timestamp

)

)

newInstance

(

value

entityType

timestamp

)

@DoNotImplement interface IdentityService

Module Contents

open fun assertOwnership(party:

anonymousParty

)

abstract val caCertStore:

CertStore

abstract fun certificateFromKey(owningKey:

)

abstract fun externalIdForPublicKey(publicKey:

)

abstract fun getAllIdentities():

exactMatch

)

)

abstract fun publicKeysForExternalId(externalId:

)

abstract fun registerKey(publicKey:

party

externalId

)

open fun requireWellKnownPartyFromAnonymous(party:

)

abstract val trustAnchor:

abstract fun verifyAndRegisterIdentity(identity:

abstract val trustRoot:

X509Certificate

)

open fun wellKnownPartyFromAnonymous(party:

)

open fun wellKnownPartyFromAnonymous(partyRef:

)

)

class IllegalFlowLogicException :

IllegalArgumentException

Module Contents

msg

)

class InMemoryMessagingNetwork :

msg

)

data class DistributedServiceHandle :

Module Contents

MessageRecipientGroup

Module Contents

DistributedServiceHandle(party:

)

interface LatencyCalculator

Module Contents

abstract fun between(sender:

receiver

)

class MockMessagingService

class MessageTransfer

Module Contents

Module Contents

)

data class PeerHandle :

@DoNotImplement sealed class ServicePeerAllocationStrategy

Module Contents

name

)

)

Module Contents

class Random :

Module Contents

Random(random:

SplittableRandom

)

pickFrom

)

Module Contents

RoundRobin()

pickFrom

abstract fun <A> pickNext(service:

)

pickFrom

val receivedMessages: <ERROR CLASS><

)

val endpointsExternal:

)

val sentMessages: <ERROR CLASS><

fun stop():

@DoNotImplement interface InProcess :

Module Contents

registerInitiatedFlow

(

initiatedFlowClass

)

open fun <T> startFlow(logic:

)

interface IndirectStatePersistable<T :

abstract val compositeKey:

Module Contents

@Target([AnnotationTarget.CLASS]) annotation class InitiatedBy

Module Contents

out

)

out

@Target([AnnotationTarget.CLASS]) @Inherited annotation class InitiatingFlow

Module Contents

InitiatingFlow(version:

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

data class InvocationContext

Module Contents

trace

actor

externalTrace

impersonatedActor

)

fun scheduled(scheduledState:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

trace

actor

externalTrace

impersonatedActor

)

val impersonatedActor:

Actor

fun newInstance(origin:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

trace

externalTrace

impersonatedActor

)

trace

externalTrace

impersonatedActor

arguments

)

trace

externalTrace

)

sealed class InvocationOrigin

owningLegalIdentity

trace

externalTrace

)

externalTrace

)

Module Contents

Module Contents

)

Module Contents

)

InvocationOrigin

Module Contents

)

Module Contents

owningLegalIdentity

)

fun principal():

Principal

abstract fun principal():

Module Contents

Principal

data class Issued<out P :

Module Contents

Issued(issuer:

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

product

)

object JacksonSupport

Module Contents

object ~~AmountDeserializer~~

Module Contents

object ~~AmountSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~AnonymousPartyDeserializer~~

Module Contents

object ~~AnonymousPartySerializer~~

Module Contents

generator

provider

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~CordaX500NameDeserializer~~

Module Contents

object ~~CordaX500NameSerializer~~

Module Contents

generator

provider

)

class ~~IdentityObjectMapper~~ :

IdentityObjectMapper(identityService:

Module Contents

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

class ~~NoPartyObjectMapper~~ :

NoPartyObjectMapper(factory: <ERROR CLASS>, isFullParties:

Module Contents

)

)

)

)

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~NodeInfoDeserializer~~

Module Contents

object ~~NodeInfoSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, ctxt: <ERROR CLASS>):

object ~~OpaqueBytesDeserializer~~

Module Contents

object ~~OpaqueBytesSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~PartyDeserializer~~

Module Contents

@DoNotImplement interface PartyObjectMapper

Module Contents

abstract val isFullParties:

)

)

abstract fun partyFromKey(owningKey:

)

)

object ~~PartySerializer~~

Module Contents

gen

provider

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~PublicKeyDeserializer~~

Module Contents

object ~~PublicKeySerializer~~

Module Contents

generator

provider

)

class ~~RpcObjectMapper~~ :

Module Contents

RpcObjectMapper(rpc:

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

class ~~SecureHashDeserializer~~<T :

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

Module Contents

SecureHashDeserializer()

object ~~SecureHashSerializer~~

Module Contents

generator

provider

)

abstract class ~~SignedTransactionMixin~~

Module Contents

SignedTransactionMixin()

abstract fun getId():

abstract fun getInputs():

abstract fun getNotary():

abstract fun getNotaryChangeTx():

abstract fun getRequiredSigningKeys():

protected abstract fun getSigs():

protected abstract fun getTransaction():

abstract fun getTx():

abstract fun getTxBits():

object ~~ToStringSerializer~~

Module Contents

generator

provider

)

abstract fun getAvailableComponentHashes():

abstract class ~~WireTransactionMixin~~

Module Contents

WireTransactionMixin()

abstract fun getAvailableComponents():

abstract fun getMerkleTree():

abstract fun getOutputStates():

fun createDefaultMapper(rpc:

val ~~cordaModule~~: <ERROR CLASS>

factory

fuzzyIdentityMatch

fullParties

fun createInMemoryMapper(identityService:

)

factory

fuzzyIdentityMatch

fullParties

fun createNonRpcMapper(factory: <ERROR CLASS> = JsonFactory(), fullParties:

)

JmxPolicy(jmxHttpServerPortAllocation:

)

data class JmxPolicy

Module Contents

JmxPolicy()

JmxPolicy(startJmxHttpServer:

)

jmxHttpServerPortAllocation

)

fun defaultEnabled():

val jmxHttpServerPortAllocation:

val startJmxHttpServer:

@Target([AnnotationTarget.FILE, AnnotationTarget.CLASS]) @CordaInternal annotation class KeepForDJVM

Module Contents

KeepForDJVM()

@DoNotImplement interface KeyManagementService

Module Contents

abstract fun filterMyKeys(candidateKeys:

)

abstract fun freshKey():

abstract fun freshKey(externalId:

)

revocationEnabled

)

revocationEnabled

externalId

)

abstract fun sign(bytes:

publicKey

)

abstract fun sign(signableData:

SignableData

publicKey

)

class KilledFlowException :

Module Contents

)

message

)

class LedgerDSL<out T :

out

Module Contents

LedgerDSL(interpreter:

notary

)

val interpreter:

output

(

)

outputStateAndRef

(

)

fun <S :

retrieveOutput

(

clazz

label

)

fun transaction(label:

transactionBuilder

dsl

(

)

)

(

)

)

fun unverifiedTransaction(label:

transactionBuilder

dsl

(

)

)

@DoNotImplement interface LedgerDSLInterpreter<out T :

abstract fun _transaction(transactionLabel:

Module Contents

transactionBuilder

dsl

(

)

)

(

)

)

abstract fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

abstract fun attachment(attachment:

)

class LedgerTransaction :

Module Contents

outputs

commands

attachments

notary

timeWindow

privacySalt

)

data class InOutGroup<out T :

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

out

Module Contents

outputs

groupingKey

)

commandsOfType

(

clazz

)

commandsOfType

(

)

operator fun component10():

CommandWithParties

@CordaInternal fun createForSandbox(inputs:

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

references

digestService

)

)

filterCommands

(

clazz

predicate

)

filterCommands

(

crossinline

predicate

(

)

)

filterInRefs

(

clazz

predicate

)

filterInRefs

(

crossinline

predicate

(

)

)

filterInputs

(

clazz

predicate

)

filterInputs

(

crossinline

predicate

(

)

)

filterReferenceInputRefs

(

clazz

predicate

)

filterReferenceInputRefs

(

crossinline

predicate

(

)

)

filterReferenceInputs

(

clazz

predicate

)

filterReferenceInputs

(

crossinline

predicate

(

)

)

findCommand

(

clazz

predicate

)

findCommand

(

crossinline

predicate

(

)

)

findInRef

(

clazz

predicate

)

findInRef

(

crossinline

predicate

(

)

)

findInput

(

clazz

predicate

)

findInput

(

crossinline

predicate

(

)

)

findReference

(

clazz

predicate

)

findReference

(

crossinline

predicate

(

)

)

findReferenceInputRef

(

clazz

predicate

)

findReferenceInputRef

(

crossinline

predicate

(

)

)

fun getAttachment(index:

)

fun getReferenceInput(index:

fun getAttachment(id:

)

getCommand

(

index

)

)

)

groupStates

(

ofType

selector

(

)

InOutGroup

groupStates

(

noinline

selector

(

)

inRef

(

index

)

inRefsOfType

(

clazz

)

inRefsOfType

(

)

inputsOfType

(

clazz

)

inputsOfType

(

)

referenceInputRefsOfType

(

clazz

)

referenceInputRefsOfType

(

)

referenceInputsOfType

(

clazz

)

@CordaInternal fun specialise(alternateVerifier: (

referenceInputsOfType

(

)

@CordaInternal fun <T> transform(transformer: (

)

Verifier

)

SerializedStateAndRef

SerializedStateAndRef

)

fun verify():

@Target([AnnotationTarget.CLASS]) annotation class LegalProseReference

Module Contents

LegalProseReference(uri:

)

val uri:

enum class LikenessOperator :

Module Contents

class LinearPointer<T :

Module Contents

type

)

type

isResolved

)

)

)

)

interface LinearState :

Module Contents

abstract val linearId:

MappedSchema(schemaFamily:

open class MappedSchema

Module Contents

version

mappedTypes

)

open val migrationResource:

)

object MappedSchemaValidator

Module Contents

class SchemaCrossReferenceReport

Module Contents

SchemaCrossReferenceReport(schema:

entity

referencedSchema

fieldOrMethod

fieldOrMethodType

)

fun crossReferencesToOtherMappedSchema(schema:

)

fun fieldsFromOtherMappedSchema(schema:

)

fun methodsFromOtherMappedSchema(schema:

)

class MaxRpcRetryException :

MaxRpcRetryException(maxNumberOfRetries:

Module Contents

method

cause

class MaybeSerializedSignedTransaction :

)

MaybeSerializedSignedTransaction(id:

Module Contents

serialized

nonSerialised

)

fun payloadContentDescription():

fun serializedByteCount():

sealed class MerkleTree

Module Contents

Module Contents

)

Module Contents

left

right

)

)

class MerkleTreeException :

nodeDigestService

)

MerkleTreeException(reason:

Module Contents

)

val reason:

interface MessageRecipientGroup :

interface MessageRecipients

class MissingAttachmentsException :

Module Contents

)

class MissingAttachmentsRuntimeException :

message

)

Module Contents

message

)

)

class MissingContractAttachments :

message

cause

)

MissingContractAttachments(states:

Module Contents

contractsClassName

minimumRequiredContractClassVersion

Version

)

class MockAttachmentStorage :

fun getAttachmentIdAndBytes(jar:

Module Contents

MockAttachmentStorage()

)

fun getLatestContractAttachments(contractClassName:

minContractVersion

)

fun hasAttachment(attachmentId:

)

)

fun importContractAttachment(contractClassNames:

uploader

filename

)

uploader

jar

attachmentId

signers

)

fun importContractAttachment(attachmentId:

contractAttachment

ContractAttachment

)

fun importOrGetAttachment(jar:

)

fun openAttachment(id:

)

fun queryAttachments(criteria:

sorting

)

MockNetFlowTimeOut(timeout:

class MockNetFlowTimeOut

Module Contents

maxRestartCount

backoffBase

)

class MockNetNotaryConfig

Module Contents

MockNetNotaryConfig(validating:

val extraConfig: <ERROR CLASS>?

extraConfig

className

serviceLegalName

)

val serviceLegalName:

val validating:

open class MockNetwork

Module Contents

parameters

)

MockNetwork(parameters:

)

defaultParameters

networkSendManuallyPumped

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

fun baseDirectory(nodeId:

)

)

val ~~cordappPackages~~:

fun createNode(parameters:

)

fun createNode(legalName:

forcedID

entropyRoot

configOverrides

)

fun createPartyNode(legalName:

)

fun createUnstartedNode(parameters:

)

fun createUnstartedNode(legalName:

forcedID

entropyRoot

configOverrides

)

val defaultNotaryIdentity:

val defaultNotaryNode:

val defaultParameters:

fun runNetwork(rounds:

)

data class MockNetworkNotarySpec

Module Contents

validating

className

)

data class MockNetworkParameters

validating

)

Module Contents

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

MockNetworkParameters(cordappsForAllNodes:

)

)

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

cordappsForAllNodes

fun copy(networkSendManuallyPumped:

)

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

)

val notarySpecs:

val threadPerNode:

)

)

fun withNetworkSendManuallyPumped(networkSendManuallyPumped:

)

)

fun withServicePeerAllocationStrategy(servicePeerAllocationStrategy:

)

fun withThreadPerNode(threadPerNode:

)

class MockNodeConfigOverrides

Module Contents

MockNodeConfigOverrides(extraDataSourceProperties:

notary

flowTimeout

)

val extraDataSourceProperties:

data class MockNodeParameters

Module Contents

legalName

entropyRoot

configOverrides

)

legalName

entropyRoot

configOverrides

additionalCordapps

)

val configOverrides:

legalName

entropyRoot

configOverrides

)

)

fun withConfigOverrides(configOverrides:

)

fun withEntropyRoot(entropyRoot:

)

fun withForcedID(forcedID:

)

fun withLegalName(legalName:

)

open class MockServices :

Module Contents

initialIdentity

identityService

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

keyManagementService

)

initialIdentityName

identityService

key

vararg

moreKeys

)

initialIdentityName

identityService

)

)

identityService

key

vararg

moreKeys

)

identityService

)

initialIdentityName

identityService

networkParameters

)

MockServices(firstIdentity: <ERROR CLASS>, vararg moreIdentities: <ERROR CLASS>)

initialIdentityName

identityService

networkParameters

key

)

MockServices(firstIdentity: <ERROR CLASS>, networkParameters:

vararg

moreIdentities

)

firstIdentity

vararg

moreIdentities

)

firstIdentity

networkParameters

fun addMockCordapp(contractClassName:

vararg

moreIdentities

)

MockServices()

)

open val contractUpgradeService:

val attachments:

MockAttachmentStorage

open val clock:

TestClock

cordaService

(

type

)

val cordappClassloader:

open val cordappProvider:

open val diagnosticsService:

open val identityService:

open fun jdbcSession():

open val keyManagementService:

open fun loadContractAttachment(stateRef:

open fun loadState(stateRef:

)

)

open fun loadStates(stateRefs:

)

fun makeTestDataSourceProperties(nodeName:

fun makeTestDatabaseAndMockServices(cordappPackages:

)

Properties

identityService

initialIdentity

networkParameters

vararg

moreKeys

)

fun makeTestDatabaseAndPersistentServices(cordappPackages:

initialIdentity

networkParameters

moreKeys

moreIdentities

cacheFactory

TestingNamedCacheFactory

)

open val myInfo:

open val networkMapCache:

open val networkParameters:

open var networkParametersService:

open fun recordTransactions(statesToRecord:

txs

)

open fun registerUnloadHandler(runOnStop: () ->

protected val servicesForResolution:

)

Nothing

open val validatedTransactions:

open val vaultService:

open fun <T> withEntityManager(block: <ERROR CLASS>.() ->

)

open fun withEntityManager(block:

)

interface MoveCommand :

Module Contents

abstract val contract:

out

class MultiRPCClient<I :

Module Contents

rpcOpsClass

username

password

configuration

)

rpcOpsClass

username

password

classLoader

configuration

)

rpcOpsClass

username

password

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

customSerializers

configuration

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

rpcOpsClass

username

password

customSerializers

configuration

fun addConnectionListener(listener:

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

)

fun close():

fun removeConnectionListener(listener:

data class MultilateralNetState<P :

)

MultilateralNetState(template:

Module Contents

)

val template:

interface MultilateralNettableState<out T :

abstract val multilateralNetState:

Module Contents

interface NamedByHash

Module Contents

interface NetCommand :

Module Contents

abstract val type:

NetType

interface NetState<P :

interface NettableState<N :

Module Contents

abstract val template:

Module Contents

out

MultilateralNettableState

data class NetworkHostAndPort

Module Contents

NetworkHostAndPort(host:

port

)

)

interface NetworkMapCache :

NetworkMapCacheBase

Module Contents

sealed class MapChange

Module Contents

Module Contents

)

data class Modified :

Module Contents

previousNode

)

Module Contents

)

abstract fun getNodeByLegalIdentity(party:

)

@DoNotImplement interface NetworkMapCacheBase

Module Contents

abstract val allNodes:

abstract val changed: <ERROR CLASS><

MapChange

abstract fun getNodeByAddress(address:

)

abstract fun getNodeByLegalName(name:

)

abstract fun getNodesByLegalIdentityKey(identityKey:

)

abstract fun getNodesByLegalName(name:

)

open fun getNotary(name:

)

abstract fun getPartyInfo(party:

)

open fun getPeerByLegalName(name:

)

abstract fun getPeerCertificateByLegalName(name:

)

abstract fun isNotary(party:

)

abstract fun isValidatingNotary(party:

)

abstract val nodeReady:

abstract val notaryIdentities:

data class NetworkParameters

Module Contents

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

val maxTransactionSize:

val whitelistedContractImplementations:

val packageOwnership:

data class NetworkParametersHash

Module Contents

NetworkParametersHash(hash:

)

@DoNotImplement interface NetworkParametersService

Module Contents

abstract val currentHash:

abstract val defaultHash:

abstract fun lookup(hash:

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class NoConstraintPropagation

Module Contents

NoConstraintPropagation()

data class NodeDiagnosticInfo

Module Contents

NodeDiagnosticInfo(version:

revision

platformVersion

vendor

cordapps

)

@DoNotImplement interface NodeHandle :

abstract val baseDirectory:

Module Contents

abstract val jmxAddress:

abstract val nodeInfo:

abstract val p2pAddress:

abstract val rpc:

abstract val rpcAddress:

abstract val rpcAdminAddress:

fun identityAndCertFromX500Name(name:

abstract val rpcUsers:

Module Contents

legalIdentitiesAndCerts

platformVersion

serial

)

)

fun identityFromX500Name(name:

)

fun isLegalIdentity(party:

)

fun isLegalIdentity(name:

)

val legalIdentitiesAndCerts:

data class NodeParameters

Module Contents

NodeParameters()

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

out

out

out

val logLevelOverride:

val startInSameProcess:

val verifierType:

)

fun withCustomOverrides(customOverrides:

)

fun withFlowOverrides(flowOverrides:

out

out

)

fun withLogLevelOverride(logLevelOverride:

)

fun withMaximumHeapSize(maximumHeapSize:

)

fun withProvidedName(providedName:

)

fun withRpcUsers(rpcUsers:

User

)

fun withStartInSameProcess(startInSameProcess:

)

fun withVerifierType(verifierType:

)

data class NodeVersionInfo

Module Contents

NodeVersionInfo(releaseVersion:

revision

platformVersion

vendor

)

class NonEmptySet<T> :

Module Contents

fun <T> copyOf(elements:

)

)

)

)

second

vararg

rest

)

data class NotarisationPayload

fun parallelStream():

Module Contents

NotarisationPayload(transaction:

requestSignature

)

val coreTransaction:

val requestSignature:

val signedTransaction:

val transaction:

class NotarisationRequest

Module Contents

NotarisationRequest(statesToConsume:

transactionId

)

data class NotarisationRequestSignature

Module Contents

NotarisationRequestSignature(digitalSignature:

platformVersion

)

val digitalSignature:

val platformVersion:

data class NotarisationResponse

Module Contents

NotarisationResponse(signatures:

)

@InitiatingFlow class NotaryChangeFlow<out T :

Instigator

NotaryChangeFlow(originalState:

Module Contents

newNotary

progressTracker

)

class NotaryChangeLedgerTransaction :

NotaryChangeLedgerTransaction(inputs:

Module Contents

notary

newNotary

sigs

)

notary

newNotary

sigs

)

)

)

data class NotaryChangeWireTransaction :

Module Contents

NotaryChangeWireTransaction(inputs:

)

notary

newNotary

)

digestService

)

Module Contents

)

sigs

)

sigs

)

sealed class NotaryError

Module Contents

data class Conflict :

Module Contents

consumedStates

)

val consumedStates:

Module Contents

)

const val NUM_STATES:

data class RequestSignatureInvalid :

RequestSignatureInvalid(cause:

Module Contents

)

data class TimeWindowInvalid :

TimeWindowInvalid(currentTime:

Module Contents

txTimeWindow

data class TransactionInvalid :

)

val ~~INSTANCE~~:

TransactionInvalid(cause:

Module Contents

)

object ~~WrongNotary~~ :

class NotaryException :

@DoNotImplement @InitiatingFlow class Client : BackpressureAwareTimedFlow<

Module Contents

NotaryException(error:

txId

)

Module Contents

Module Contents

skipVerification

)

progressTracker

)

progressTracker

skipVerification

)

protected fun checkTransaction():

open val isTimeoutEnabled:

protected fun notarise(notaryParty:

)

NotarisationResponse

protected fun validateResponse(response:

notaryParty

)

data class NotaryHandle

Module Contents

NotaryHandle(identity:

validating

nodeHandles

)

data class NotaryInfo

Module Contents

validating

)

data class NotarySpec

Module Contents

validating

rpcUsers

verifierType

cluster

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

startInProcess

)

validating

rpcUsers

verifierType

cluster

startInProcess

)

validating

rpcUsers

verifierType

cluster

)

Module Contents

object NullPublicKey :

Module Contents

)

enum class NullOperator :

data class ObjectWithCompatibleContext<out T :

Module Contents

IS_NULL

NOT_NULL

ObjectWithCompatibleContext(obj:

Module Contents

context

)

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

Module Contents

)

data class SetLifecycle :

Module Contents

SetLifecycle(lifecycle:

)

data class Settle<P :

Module Contents

)

Module Contents

val multilateralNetState:

Module Contents

obligor

template

quantity

beneficiary

)

val bilateralNetState:

)

)

Terms(acceptableContracts:

newOwner

)

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

)

object ObligationUtils

Module Contents

fun generateCashIssue(tx:

obligor

acceptableContract

amount

dueBefore

beneficiary

notary

)

generateCloseOutNetting

(

signer

abstract class OnLedgerAsset<T :

vararg

inputs

)

generateExit

(

amountIssued

assetStates

)

generateIssue

(

obligor

issuanceDef

pennies

beneficiary

notary

)

generatePaymentNetting

(

issued

notary

vararg

inputs

)

generateSetLifecycle

(

statesAndRefs

lifecycle

notary

)

generateSettle

(

statesAndRefs

assetStatesAndRefs

moveCommand

notary

)

out

Module Contents

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands:

)

fun ~~generateExit~~(tx:

amountIssued

assetStates

)

amountIssued

assetStates

payChangeTo

)

~~generateExit~~

(

amountIssued

assetStates

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

generateExit

(

amountIssued

assetStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

abstract fun generateExitCommand(amount:

generateExitCommand

(

)

)

)

generateIssue

(

transactionState

issueCommand

)

abstract fun generateMoveCommand():

generateSpend

(

amount

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

generateSpend

(

payments

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

open class OpaqueBytes :

Module Contents

)

)

class OpaqueBytesSubSequence :

OpaqueBytesSubSequence(bytes:

Module Contents

offset

size

)

@DoNotImplement interface Operator

@DoNotImplement interface OutOfProcess :

@DoNotImplement interface OutputStateLookup

Module Contents

abstract val process:

Process

Module Contents

abstract fun <S :

retrieveOutputStateAndRef

(

clazz

label

)

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

data class PageSpecification

Module Contents

PageSpecification(pageNumber:

pageSize

)

data class ParametersUpdateInfo

Module Contents

ParametersUpdateInfo(hash:

parameters

description

updateDeadline

)

class PartialMerkleTree

Module Contents

PartialMerkleTree(root:

PartialTree

)

sealed class PartialTree

Module Contents

data class IncludedLeaf :

Module Contents

)

Module Contents

)

Module Contents

right

)

right

hashAlgorithm

)

right

)

fun build(merkleRoot:

includeHashes

)

@CordaInternal fun leafIndex(leaf:

)

fun rootAndUsedHashes(node:

usedHashes

)

fun verify(merkleRootHash:

hashesToCheck

)

Module Contents

)

owningKey

)

)

data class PartyAndAmount<T :

class PartyAndCertificate

Module Contents

PartyAndAmount(party:

amount

)

Module Contents

PartyAndCertificate(certPath:

)

)

fun verify(trustAnchor:

)

fun verify(trustAnchors:

)

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

sealed class PartyInfo

Module Contents

data class DistributedNode :

Module Contents

DistributedNode(party:

)

val party:

class PermissionException :

data class SingleNode :

Module Contents

addresses

)

enum class PaymentRule

Module Contents

InAdvance

InArrears

ClientRelevantError

Module Contents

PermissionException(msg:

)

val msg:

class PersistentState :

PersistentState(stateRef:

Module Contents

)

var stateRef:

data class PersistentStateRef :

PersistentStateRef(stateRef:

Module Contents

@DoNotImplement abstract class PortAllocation

)

PersistentStateRef(txId:

index

)

Module Contents

PortAllocation()

const val DEFAULT_START_PORT:

const val FIRST_EPHEMERAL_PORT:

@DoNotImplement open class ~~Incremental~~ :

Incremental(startingPort:

Module Contents

)

open fun ~~nextPort~~():

val ~~portCounter~~:

AtomicInteger

val defaultAllocator:

fun nextHostAndPort():

abstract fun nextPort():

class PrivacySalt :

Module Contents

PrivacySalt(saltLength:

)

)

fun createFor(algorithm:

)

ProgressTracker(vararg inputSteps:

class ProgressTracker

Module Contents

open val changes: <ERROR CLASS><

)

sealed class Change

Module Contents

data class Position :

Module Contents

newStep

)

data class Rendering :

Module Contents

ofStep

)

data class Structural :

Module Contents

parent

)

Module Contents

)

Module Contents

)

Module Contents

)

open fun childProgressTracker():

)

val changes: <ERROR CLASS><

open val extraAuditData:

Module Contents

)

var currentStep:

val currentStepRecursive:

fun endWithError(error:

)

fun getChildProgressTracker(step:

)

fun setChildProgressTracker(step:

childProgressTracker

)

val steps: <ERROR CLASS>

val stepsTreeChanges: <ERROR CLASS><

val stepsTreeIndexChanges: <ERROR CLASS><

val topLevelTracker:

interface PropertyDelegate<out T>

Module Contents

abstract operator fun getValue(thisRef:

sealed class QueryCriteria :

property

KProperty

)

Module Contents

abstract class CommonQueryCriteria :

Module Contents

)

open val constraintTypes:

Module Contents

CommonQueryCriteria()

open val constraints:

abstract val contractStateTypes:

out

open val exactParticipants:

open val externalIds:

open val participants:

open val relevancyStatus:

abstract val status:

)

data class FungibleAssetQueryCriteria :

Module Contents

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

exactParticipants

)

out

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

)

)

out

)

)

fun withIssuer(issuer:

)

fun withOwner(owner:

)

)

)

)

)

fun withissuerRef(issuerRef:

)

data class FungibleStateQueryCriteria :

FungibleStateQueryCriteria(participants:

Module Contents

quantity

status

contractStateTypes

out

relevancyStatus

)

out

)

out

)

)

)

)

)

data class LinearStateQueryCriteria :

Module Contents

uuid

externalId

status

contractStateTypes

out

relevancyStatus

)

uuid

externalId

status

contractStateTypes

out

)

linearId

status

contractStateTypes

out

relevancyStatus

)

linearId

status

contractStateTypes

out

)

uuid

externalId

status

contractStateTypes

out

relevancyStatus

exactParticipants

)

out

uuid

externalId

status

contractStateTypes

out

)

uuid

externalId

status

contractStateTypes

out

relevancyStatus

)

)

out

)

)

fun withExternalId(externalId:

)

)

)

)

fun withUuid(uuid:

)

data class SoftLockingCondition

Module Contents

)

Module Contents

SoftLockingCondition(type:

lockIds

)

enum class SoftLockingType

Module Contents

LOCKED_ONLY

SPECIFIED

UNLOCKED_AND_SPECIFIED

UNLOCKED_ONLY

data class TimeCondition

Module Contents

predicate

)

enum class TimeInstantType

Module Contents

data class VaultCustomQueryCriteria<L :

RECORDED

Module Contents

status

contractStateTypes

out

)

status

contractStateTypes

out

relevancyStatus

)

out

status

contractStateTypes

out

)

)

out

)

fun withExpression(expression:

)

)

)

data class VaultQueryCriteria :

Module Contents

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

)

)

contractStateTypes

out

)

contractStateTypes

out

stateRefs

)

contractStateTypes

out

stateRefs

notary

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

exactParticipants

)

out

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

)

val softLockingCondition:

)

fun withConstraintTypes(constraintTypes:

)

fun withConstraints(constraints:

)

out

)

)

fun withExternalIds(externalIds:

)

fun withNotary(notary:

)

)

)

fun withSoftLockingCondition(softLockingCondition:

SoftLockingCondition

)

fun withStateRefs(stateRefs:

)

)

fun withTimeCondition(timeCondition:

TimeCondition

)

)

)

interface QueryableState :

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas():

@DoNotImplement interface RPCConnection<out I :

Module Contents

abstract fun forceClose():

abstract fun notifyServerAndClose():

abstract val serverProtocolVersion:

abstract val proxy:

interface RPCConnectionListener<I :

interface ConnectionContext<I :

Module Contents

abstract val connectionOpt:

Module Contents

RPCConnection

abstract val throwableOpt:

abstract val userName:

abstract fun onConnect(context:

)

abstract fun onDisconnect(context:

)

abstract fun onPermanentFailure(context:

)

open class RPCException :

Module Contents

RPCException(msg:

)

RPCException(message:

cause

@DoNotImplement interface RPCOps

)

Module Contents

abstract val protocolVersion:

@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables

Module Contents

RPCReturnsObservables()

@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion

Module Contents

RPCSinceVersion(version:

)

class ReceiveFinalityFlow :

ReceiveFinalityFlow(otherSideSession:

Module Contents

expectedTxId

statesToRecord

)

class ReceiveStateAndRefFlow<out T :

Module Contents

ReceiveStateAndRefFlow(otherSideSession:

)

open class ReceiveTransactionFlow :

ReceiveTransactionFlow(otherSideSession:

Module Contents

protected open fun checkBeforeRecording(stx:

checkSufficientSignatures

statesToRecord

)

)

data class ReferenceStateRef

Module Contents

ReferenceStateRef(stateRef:

)

val stateRef:

data class ReferencedStateAndRef<out T :

ReferencedStateAndRef(stateAndRef:

Module Contents

)

Module Contents

using

(

expr

)

class ResultSerializationException :

ResultSerializationException(e: MissingSerializerException)

Module Contents

object SampleCashSchemaV1 :

Module Contents

PersistentCashState(ownerHash:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object SampleCashSchemaV2 :

Module Contents

PersistentCashState(currency:

FungibleState

Module Contents

participants

owner

quantity

issuerParty

issuerRef

)

object SampleCashSchemaV3 :

Module Contents

PersistentCashState(participants:

Module Contents

owner

pennies

currency

issuer

issuerRef

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class SchedulableFlow

Module Contents

SchedulableFlow()

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

flowLogicRefFactory

)

Module Contents

abstract val scheduledAt:

data class ScheduledActivity :

ScheduledActivity(logicRef:

Module Contents

scheduledAt

)

data class ScheduledStateRef :

sealed class SecureHash :

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

Module Contents

Module Contents

bytes

)

)

)

Module Contents

)

)

fun allOnesHashFor(algorithm:

)

)

fun componentHashAs(algorithm:

bytes

)

fun concatenate(other:

)

fun concatenateAs(concatAlgorithm:

other

)

)

fun digestLengthFor(algorithm:

)

protected open fun generate(data:

)

fun getAllOnesHash():

fun getZeroHash():

fun hashAs(algorithm:

bytes

)

fun hashConcat(other:

fun nonceHashAs(algorithm:

)

bytes

)

)

fun prefixChars(prefixLen:

fun zeroHashFor(algorithm:

)

fun random(algorithm:

)

)

)

fun sha256Twice(bytes:

)

)

open class SendStateAndRefFlow :

SendStateAndRefFlow(otherSideSession:

Module Contents

stateAndRefs

open class SendTransactionFlow :

)

SendTransactionFlow(otherSide:

Module Contents

stx

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.FUNCTION]) annotation class SerializableCalculatedProperty

)

Module Contents

SerializableCalculatedProperty()

@DoNotImplement interface SerializationContext

Module Contents

Module Contents

abstract val carpenterDisabled:

abstract val customSerializers:

abstract val encoding:

abstract val encodingWhitelist:

abstract val lenientCarpenterEnabled:

abstract val objectReferencesEnabled:

abstract val preferredSerializationVersion:

abstract val preventDataLoss:

abstract val useCase:

UseCase

abstract fun ~~withAttachmentsClassLoader~~(attachmentHashes:

)

abstract fun withClassLoader(classLoader:

)

abstract fun withCustomSerializers(serializers:

)

abstract fun withEncoding(encoding:

)

abstract fun withEncodingWhitelist(encodingWhitelist:

)

abstract fun withLenientCarpenter():

abstract fun withPreferredSerializationVersion(magic:

)

abstract fun withPreventDataLoss():

abstract fun withProperties(extraProperties:

)

abstract fun withProperty(property:

value

)

abstract fun withWhitelisted(clazz:

)

abstract fun withoutCarpenter():

abstract fun withoutReferences():

interface SerializationCustomSerializer<OBJ, PROXY>

Module Contents

)

)

object SerializationDefaults

Module Contents

val P2P_CONTEXT:

val RPC_CLIENT_CONTEXT:

val RPC_SERVER_CONTEXT:

val SERIALIZATION_FACTORY:

val STORAGE_CONTEXT:

@DoNotImplement interface SerializationEncoding

abstract class SerializationFactory

Module Contents

SerializationFactory()

fun <T> asCurrent(block:

(

)

deserialize

(

byteSequence

clazz

context

)

deserializeWithCompatibleContext

(

byteSequence

clazz

context

ObjectWithCompatibleContext

)

serialize

(

obj

context

)

fun <T> withCurrentContext(context:

typealias SerializationMagic =

block

(

)

@DoNotImplement interface SerializationSchemeContext

Module Contents

interface SerializationToken

Module Contents

abstract fun fromToken(context:

)

interface SerializationWhitelist

Module Contents

interface SerializeAsToken

Module Contents

abstract fun toToken(context:

)

interface SerializeAsTokenContext

Module Contents

abstract fun getSingleton(className:

)

abstract fun putSingleton(toBeTokenized:

)

abstract val serviceHub:

class SerializedBytes<T :

Module Contents

SerializedBytes(bytes:

)

from

(

obj

serializationFactory

context

)

interface ServiceHub :

Module Contents

publicKey

)

abstract val contractUpgradeService:

)

cordaService

(

type

)

publicKey

)

)

publicKey

)

)

abstract val diagnosticsService:

open fun getAppContext():

abstract fun jdbcSession():

abstract val keyManagementService:

abstract val myInfo:

abstract val networkMapCache:

txs

)

first

vararg

remaining

)

abstract fun recordTransactions(statesToRecord:

txs

)

open fun recordTransactions(first:

vararg

remaining

)

open fun recordTransactions(txs:

)

abstract fun registerUnloadHandler(runOnStop: () ->

)

publicKey

)

)

signingPubKeys

)

toStateAndRef

(

stateRef

)

abstract val validatedTransactions:

abstract val vaultService:

abstract fun <T> withEntityManager(block: <ERROR CLASS>.() ->

)

abstract fun withEntityManager(block:

)

enum class ServiceLifecycleEvent

Module Contents

STATE_MACHINE_STARTED

@FunctionalInterface interface ServiceLifecycleObserver

Module Contents

abstract fun onServiceLifecycleEvent(event:

)

@DoNotImplement interface ServicesForResolution

Module Contents

abstract val attachments:

abstract val cordappProvider:

abstract val identityService:

abstract fun loadContractAttachment(stateRef:

)

abstract fun loadState(stateRef:

)

abstract fun loadStates(stateRefs:

)

abstract val networkParametersService:

open fun specialise(ltx:

)

@DoNotImplement interface SessionScope

Module Contents

abstract val session: <ERROR CLASS>

object SgxSupport

Module Contents

val isInsideEnclave:

abstract class SignTransactionFlow :

SignTransactionFlow(otherSideSession:

Module Contents

progressTracker

)

protected abstract fun checkTransaction(stx:

)

data class SignableData

Module Contents

SignableData(txId:

signatureMetadata

)

val txId:

data class SignatureAttachmentConstraint :

SignatureAttachmentConstraint(key:

Module Contents

)

data class SignatureMetadata

)

Module Contents

SignatureMetadata(platformVersion:

schemeNumberID

)

data class SignatureScheme

Module Contents

SignatureScheme(schemeNumberID:

schemeCodeName

signatureOID

alternativeOIDs

providerName

algorithmName

signatureName

algSpec

keySize

desc

)

val algSpec:

val signatureOID: <ERROR CLASS>

open class SignedData<T :

Module Contents

sig

)

protected open fun verifyData(data:

)

data class SignedTransaction :

Module Contents

SignedTransaction(ctx:

sigs

SignedTransaction(txBits:

)

sigs

)

class SignaturesMissingException :

SignatureException

SignaturesMissingException(missing:

Module Contents

descriptions

)

)

)

fun ~~isNotaryChangeTransaction~~():

val ~~notaryChangeTx~~:

operator fun plus(sig:

)

operator fun plus(sigList:

)

fun resolveBaseTransaction(servicesForResolution:

)

fun resolveContractUpgradeTransaction(services:

)

)

)

fun resolveTransactionWithSignatures(services:

)

checkSufficientSignatures

)

checkSufficientSignatures

)

@VisibleForTesting fun withAdditionalSignature(keyPair:

signatureMetadata

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList:

)

interface SingleMessageRecipient :

class SingletonSerializationToken :

Module Contents

fun fromToken(context:

)

fun registerWithContext(context:

toBeTokenized

)

singletonSerializationToken

(

toBeTokenized

SingletonSerializationToken

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

@DoNotImplement interface Attribute

)

Module Contents

)

enum class CommonStateAttribute :

Module Contents

Module Contents

enum class FungibleStateAttribute :

Module Contents

enum class LinearStateAttribute :

Module Contents

data class SortColumn

Module Contents

SortColumn(sortAttribute:

direction

)

enum class VaultStateAttribute :

Module Contents

sealed class SortAttribute

Module Contents

data class Custom :

SortAttribute

Module Contents

Custom(entityStateClass:

out

entityStateColumnName

)

val entityStateClass:

out

val entityStateColumnName:

data class SourceAndAmount<T :

data class Standard :

Module Contents

)

out

data class StackFrameDataToken

Module Contents

SourceAndAmount(source:

amount

ref

)

Module Contents

StackFrameDataToken(className:

)

val className:

@Target([AnnotationTarget.CLASS]) annotation class StartableByRPC

Module Contents

StartableByRPC()

@Target([AnnotationTarget.CLASS]) annotation class StartableByService

Module Contents

StartableByService()

class StartedMockNode

Module Contents

findStateMachines

(

flowClass

)

)

registerInitiatedFlow

(

initiatedFlowClass

)

registerInitiatedFlow

(

initiatingFlowClass

out

initiatedFlowClass

)

fun <T> startFlow(logic:

)

fun stop(): <ERROR CLASS>

fun <T> transaction(statement: () ->

)

data class StateAndContract

Module Contents

StateAndContract(state:

contract

)

data class StateAndRef<out T :

Module Contents

ref

)

val state:

data class StateConsumptionDetails

Module Contents

)

type

enum class ConsumedStateType

)

Module Contents

INPUT_STATE

REFERENCE_INPUT_STATE

fun copy(hashOfTransactionId:

)

val hashOfTransactionId:

data class StateMachineInfo

Module Contents

flowLogicClassName

initiator

progressTrackerStepAndUpdates

invocationContext

)

flowLogicClassName

initiator

progressTrackerStepAndUpdates

)

val flowLogicClassName:

val ~~initiator~~:

val progressTrackerStepAndUpdates:

data class StateMachineRunId

Module Contents

StateMachineRunId(uuid:

)

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val stateMachineRunId:

val transactionId:

sealed class StateMachineUpdate

Module Contents

data class Added :

StateMachineUpdate

Module Contents

Added(stateMachineInfo:

)

interface StatePersistable

val stateMachineInfo:

Module Contents

result

)

@DoNotImplement sealed class StatePointer<T :

Module Contents

abstract val isResolved:

linearPointer

(

state

isResolved

)

abstract val pointer:

abstract fun resolve(services:

)

abstract fun resolve(ltx:

)

open class StateReplacementException :

staticPointer

(

stateAndRef

isResolved

)

Module Contents

index

)

StateReplacementException(message:

Module Contents

cause

class StatesNotAvailableException :

)

StatesNotAvailableException(message:

Module Contents

cause

)

enum class StatesToRecord

Module Contents

ALL_VISIBLE

NONE

ONLY_RELEVANT

class StaticPointer<T :

Module Contents

type

)

type

isResolved

)

)

open class StringToMethodCallParser<in T :

)

)

Module Contents

out

)

inner class ParsedMethodCall<in T :

out

)

Callable

Module Contents

ParsedMethodCall(target:

method

args

)

operator fun invoke():

val method:

open class UnparseableCallException :

UnparseableCallException(command:

Module Contents

cause

)

class FailedParse :

Module Contents

FailedParse(e:

)

class MissingParameter :

MissingParameter(methodName:

Module Contents

paramName

command

)

Module Contents

NoSuchFile(filename:

class ReflectionDataMissing :

)

ReflectionDataMissing(methodName:

Module Contents

argIndex

class TooManyParameters :

)

TooManyParameters(methodName:

Module Contents

command

)

class UnknownMethod :

UnknownMethod(methodName:

Module Contents

)

val methodName:

val availableCommands:

protected val methodMap: <ERROR CLASS><

open fun paramNamesFromConstructor(ctor:

val methodParamNames:

Constructor

)

open fun paramNamesFromMethod(method:

)

command

)

fun parseArguments(methodNameHint:

parameters

args

)

fun validateIsMatchingCtor(methodNameHint:

parameters

args

)

@Target([AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER]) @CordaInternal annotation class StubOutForDJVM

Module Contents

Module Contents

)

Module Contents

fun daysToMaturity(startDate:

calendar

)

Module Contents

TestClock(delegateClock:

)

fun advanceBy(duration:

)

fun setTo(newInstant:

)

@DoNotImplement abstract class TestCordapp

Module Contents

fun findCordapp(scanPackage:

)

abstract fun withConfig(config:

)

data class TestLedgerDSLInterpreter :

TestLedgerDSLInterpreter(services:

Module Contents

)

class TypeMismatch :

Module Contents

TypeMismatch(requested:

actual

)

class VerifiesFailed :

VerifiesFailed(transactionName:

Module Contents

cause

fun _transaction(transactionLabel:

)

transactionBuilder

dsl

(

)

)

(

)

)

fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

fun attachment(attachment:

)

fun transactionName(transactionHash:

fun outputToLabel(state:

)

retrieveOutputStateAndRef

(

clazz

label

)

)

val transactionsToVerify:

val transactionsUnverified:

val wireTransactions:

data class TestTransactionDSLInterpreter :

TestTransactionDSLInterpreter(ledgerInterpreter:

Module Contents

transactionBuilder

)

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

fun attachment(attachmentId:

)

commandData

)

)

val ledgerInterpreter:

label

notary

encumbrance

attachmentConstraint

contractState

)

fun reference(stateRef:

)

val services:

fun timeWindow(data:

)

val transactionBuilder:

fun verifies():

abstract class TimeWindow

Module Contents

TimeWindow()

fun between(fromTime:

untilTime

)

abstract operator fun contains(instant:

)

fun fromOnly(fromTime:

)

fun fromStartAndDuration(fromTime:

duration

)

abstract val fromTime:

val length:

abstract val midpoint:

fun untilOnly(untilTime:

)

abstract val untilTime:

fun withTolerance(instant:

tolerance

)

class ~~TimeWindowChecker~~

Module Contents

TimeWindowChecker(clock:

)

val clock:

fun isValid(timeWindow:

)

interface TokenizableAssetInfo

Module Contents

abstract val displayTokenSize:

Module Contents

sessionId

)

Module Contents

timestamp

)

timestamp

)

Module Contents

timestamp

)

fun newInstance(invocationId:

timestamp

)

sessionId

)

open class TransactionBuilder

Module Contents

lockId

inputs

attachments

outputs

commands

window

privacySalt

)

)

fun addAttachment(attachmentId:

lockId

inputs

attachments

outputs

commands

window

privacySalt

references

serviceHub

)

)

)

vararg

keys

)

keys

)

open fun addInputState(stateAndRef:

)

)

contract

notary

encumbrance

constraint

)

contract

constraint

)

constraint

)

open fun addReferenceState(referencedStateAndRef:

)

fun attachments():

protected val attachments:

protected val commands:

protected val inputs:

protected val outputs:

protected var privacySalt:

fun referenceStates():

protected val references:

protected val serviceHub:

fun setPrivacySalt(privacySalt:

fun setTimeWindow(timeWindow:

)

)

fun setTimeWindow(time:

timeTolerance

)

)

fun toSignedTransaction(keyManagementService:

publicKey

signatureMetadata

services

)

)

schemeId

)

schemeId

properties

)

)

protected var window:

fun withItems(vararg items:

class TransactionDSL<out T :

)

TransactionDSL(interpreter:

Module Contents

notary

)

)

attachmentId

signers

jarManifestAttributes

)

attachmentId

)

fun attachments(vararg contractClassNames:

)

commandData

)

fun input(stateLabel:

)

stateLabel

)

state

)

label

notary

contractState

)

label

encumbrance

contractState

)

label

contractState

)

notary

contractState

)

encumbrance

contractState

)

contractState

)

fun reference(stateLabel:

fun reference(contractClassName:

)

state

)

tolerance

)

(

)

)

@DoNotImplement interface TransactionDSLInterpreter :

Module Contents

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

abstract fun attachment(attachmentId:

)

abstract fun command(signers:

commandData

)

abstract fun input(stateRef:

)

abstract val ledgerInterpreter:

abstract fun output(contractClassName:

label

notary

encumbrance

attachmentConstraint

contractState

)

abstract fun reference(stateRef:

)

abstract fun timeWindow(data:

)

open class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

message

class UnknownParametersException :

)

TransactionResolutionException

Module Contents

UnknownParametersException(txId:

paramsHash

)

class TransactionSignature :

DigitalSignature

Module Contents

signatureMetadata

)

signatureMetadata

partialMerkleTree

)

)

)

data class TransactionState<out T :

)

@DoNotImplement interface TransactionStorage

Module Contents

TransactionState(data:

contract

notary

encumbrance

constraint

)

Module Contents

abstract fun getTransaction(id:

)

abstract fun trackTransaction(id:

)

abstract class TransactionVerificationException :

TransactionVerificationException(txId:

Module Contents

message

cause

class BrokenTransactionException :

)

BrokenTransactionException(txId:

Module Contents

message

class ConflictingAttachmentsRejection :

)

ConflictingAttachmentsRejection(txId:

Module Contents

contractClass

)

class ConstraintPropagationRejection :

Module Contents

contractClass

inputConstraint

outputConstraint

)

class ContractConstraintRejection :

message

)

ContractConstraintRejection(txId:

Module Contents

contractClass

)

class ContractCreationError :

Module Contents

val contractClass:

class ContractRejection :

class DuplicateAttachmentsRejection :

Module Contents

Module Contents

DuplicateAttachmentsRejection(txId:

Module Contents

attachmentId

)

class InvalidAttachmentException :

InvalidAttachmentException(txId:

Module Contents

attachmentHash

)

class InvalidConstraintRejection :

InvalidConstraintRejection(txId:

Module Contents

contractClass

reason

)

class MissingAttachmentRejection :

MissingAttachmentRejection(txId:

Module Contents

contractClass

)

class MissingNetworkParametersException :

Module Contents

missingNetworkParametersHash

)

message

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(txId:

Module Contents

txNotary

outputNotary

)

class OverlappingAttachmentsException :

OverlappingAttachmentsException(txId:

Module Contents

path

)

class PackageOwnershipException :

PackageOwnershipException(txId:

Module Contents

attachmentHash

invalidClassName

packageName

)

val invalidClassName:

val packageName:

class TransactionContractConflictException :

Module Contents

state

requiredContractClassName

)

message

class TransactionDuplicateEncumbranceException :

)

Module Contents

index

)

message

class TransactionMissingEncumbranceException :

)

TransactionMissingEncumbranceException(txId:

Module Contents

missing

inOut

)

class TransactionNetworkParameterOrderingException :

Module Contents

inputStateRef

txnNetworkParameters

inputNetworkParameters

)

message

class TransactionNonMatchingEncumbranceException :

)

Module Contents

nonMatching

)

message

class TransactionNotaryMismatchEncumbranceException :

)

TransactionNotaryMismatchEncumbranceException(txId:

Module Contents

encumberedIndex

encumbranceIndex

encumberedNotary

encumbranceNotary

)

TransactionNotaryMismatchEncumbranceException(txId:

message

class TransactionRequiredContractUnspecifiedException :

)

TransactionRequiredContractUnspecifiedException(txId:

Module Contents

state

TransactionRequiredContractUnspecifiedException(txId:

)

message

class UnsupportedClassVersionError :

)

UnsupportedClassVersionError(txId:

Module Contents

message

cause

class UnsupportedHashTypeException :

)

UnsupportedHashTypeException(txId:

Module Contents

class UntrustedAttachmentsException :

)

UntrustedAttachmentsException(txId:

Module Contents

ids

)

@DoNotImplement interface TransactionWithSignatures :

open fun checkSignaturesAreValid():

Module Contents

abstract fun getKeyDescriptions(keys:

)

open fun getMissingSigners():

abstract val requiredSigningKeys:

open fun verifyRequiredSignatures(): <ERROR CLASS>

open fun verifySignaturesExcept(vararg allowedToBeMissing:

)

open fun verifySignaturesExcept(allowedToBeMissing:

)

abstract class TraversableTransaction :

Module Contents

)

val availableComponentGroups:

digestService

)

open val componentGroups:

open val networkParametersHash:

sealed class Try<out A>

Module Contents

data class Failure<out A> :

Module Contents

)

data class Success<out A> :

Module Contents

)

inline fun <B, C> combine(other:

function

(

)

fun doOnFailure(action:

)

fun doOnSuccess(action:

)

inline fun flatMap(function: (

)

)

abstract fun getOrThrow():

abstract val isFailure:

abstract val isSuccess:

inline fun map(function: (

)

inline fun <T> on(body: () ->

)

fun throwError():

object TwoPartyDealFlow

Module Contents

class Acceptor :

Secondary

Acceptor(otherSideSession:

Module Contents

progressTracker

protected open fun assembleSharedTX(handshake:

)

)

protected open fun validateHandshake(handshake:

)

Module Contents

dealBeingOffered

)

val dealBeingOffered:

data class Handshake<out T>

Module Contents

primaryIdentity

secondaryIdentity

)

val secondaryIdentity:

Instigator(otherSideSession:

class Instigator :

Primary

Module Contents

payload

progressTracker

open fun checkProposal(stx:

)

)

open val notaryParty:

open val payload:

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object SENDING_PROPOSAL :

abstract fun checkProposal(stx:

)

abstract val notaryParty:

abstract val payload:

abstract class Secondary :

Secondary(progressTracker:

Module Contents

)

protected abstract fun assembleSharedTX(handshake:

)

protected abstract fun validateHandshake(handshake:

)

class AssetMismatchException :

object TwoPartyTradeFlow

Module Contents

AssetMismatchException(expectedTypeName:

Module Contents

typeName

)

val expectedTypeName:

Module Contents

Buyer(otherSideSession:

notary

acceptablePrice

typeToBuy

out

)

notary

acceptablePrice

typeToBuy

out

anonymous

)

Module Contents

Module Contents

cashSigningPubKeys

)

val cashSigningPubKeys:

object AWAITING_PROPOSAL :

Module Contents

Seller(otherSideSession:

assetToSell

price

myParty

progressTracker

)

object VERIFYING_AND_SIGNING :

Module Contents

data class SellerTradeInfo

Module Contents

SellerTradeInfo(price:

payToIdentity

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

abstract class TypeOnlyCommandData :

)

Module Contents

TypeOnlyCommandData()

)

open fun hashCode(): <ERROR CLASS>

class UnexpectedFlowEndException :

Module Contents

cause

)

)

data class UniqueIdentifier :

cause

originalErrorId

)

UniqueIdentifier(externalId:

Module Contents

)

)

)

@VisibleForTesting fun fromString(name:

)

class UnknownAnonymousPartyException :

UnknownAnonymousPartyException(message:

Module Contents

)

class UnknownCalendar :

Module Contents

UnknownCalendar(name:

open class UnrecoverableRPCException :

)

UnrecoverableRPCException(message:

Module Contents

cause

class UntrustworthyData<out T>

)

class UnstartedMockNode

Module Contents

installCordaService

(

serviceClass

)

Module Contents

UntrustworthyData(fromUntrustedWorld:

)

@FunctionalInterface interface Validator<in T, out R> :

abstract fun validate(data:

Module Contents

)

fun <R> unwrap(validator:

Validator

)

interface UpgradedContract<in OldState :

out

NewState

abstract val legacyContract:

Module Contents

abstract fun upgrade(state:

OldState

)

NewState

interface UpgradedContractWithLegacyConstraint<in OldState :

abstract val legacyContractConstraint:

out

NewState

Module Contents

Module Contents

password

permissions

)

Module Contents

interface VariablePropertyDelegate<T> :

PropertyDelegate

Module Contents

abstract operator fun setValue(thisRef:

data class ConstraintInfo

property

KProperty

value

)

Module Contents

)

Module Contents

ConstraintInfo(constraint:

)

Module Contents

fun constraintInfo(type:

data

)

val ~~NoNotaryUpdate~~: <ERROR CLASS>

val ~~NoUpdate~~: <ERROR CLASS>

data class Page<out T :

Module Contents

statesMetadata

totalStatesAvailable

stateTypes

otherResults

)

val totalStatesAvailable:

enum class RelevancyStatus

Module Contents

NOT_RELEVANT

RELEVANT

data class StateMetadata

Module Contents

StateMetadata(ref:

val contractStateClassName:

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

relevancyStatus

constraintInfo

)

fun copy(ref:

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

)

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

relevancyStatus

)

enum class StateStatus

Module Contents

UNCONSUMED

data class Update<U :

Module Contents

produced

flowId

type

references

)

containsType

(

)

class VaultQueryException :

containsType

(

clazz

status

)

produced

flowId

type

)

operator fun plus(rhs:

)

enum class UpdateType

Module Contents

Module Contents

)

cause

@DoNotImplement interface VaultService

)

Module Contents

_queryBy

(

criteria

paging

sorting

contractStateType

out

)

_trackBy

(

criteria

paging

sorting

contractStateType

out

)

abstract fun addNoteToTransaction(txnId:

noteText

)

abstract fun getTransactionNotes(txnId:

)

queryBy

(

contractStateType

out

)

queryBy

(

contractStateType

out

criteria

)

queryBy

(

contractStateType

out

paging

)

queryBy

(

contractStateType

out

criteria

paging

)

queryBy

(

contractStateType

out

criteria

sorting

)

queryBy

(

contractStateType

abstract val rawUpdates: <ERROR CLASS><

out

criteria

paging

sorting

)

abstract fun softLockRelease(lockId:

stateRefs

)

abstract fun softLockReserve(lockId:

stateRefs

)

trackBy

(

contractStateType

out

)

trackBy

(

contractStateType

out

criteria

)

trackBy

(

contractStateType

out

paging

)

trackBy

(

contractStateType

out

criteria

paging

)

trackBy

(

contractStateType

out

criteria

sorting

)

trackBy

(

contractStateType

out

criteria

paging

sorting

)

tryLockFungibleStatesForSpending

(

lockId

eligibleStatesQuery

amount

contractStateType

out

)

open fun whenConsumed(ref:

)

enum class VerifierType

Module Contents

InMemory

@DoNotImplement interface Verifies

Module Contents

open fun fails():

open infix fun fails with(msg:

)

open fun failsWith(expectedMessage:

)

abstract fun verifies():

data class WaitTimeUpdate

Module Contents

WaitTimeUpdate(waitTime:

)

val waitTime:

WebserverHandle(listenAddress:

data class ~~WebserverHandle~~

Module Contents

process

)

object WhitelistedByZoneAttachmentConstraint :

Module Contents

)

class WireTransaction :

Module Contents

)

privacySalt

)

WireTransaction(inputs:

attachments

outputs

commands

notary

timeWindow

privacySalt

)

privacySalt

digestService

)

)

fun checkSignature(sig:

)

@CordaInternal fun ~~createComponentGroups~~(inputs:

outputs

commands

attachments

notary

timeWindow

)

)

@CordaInternal fun resolveStateRefBinaryComponent(stateRef:

services

)

)

fun ~~toLedgerTransaction~~(resolveIdentity: (

)

resolveAttachment

(

)

resolveStateRef

(

)

class WithReferencedStatesFlow<T :

resolveContractAttachment

(

)

)

WithReferencedStatesFlow(progressTracker:

Module Contents

class ZoneVersionTooLowException :

flowLogicProducer

(

)

)

ZoneVersionTooLowException(message:

Module Contents

java.lang.management.ThreadInfo

)

Module Contents

ThreadInfo

asString

(

maxFrames

)

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

sign

(

bytesToSign

)

sign

(

bytesToSign

)

sign

(

signableData

)

verify

(

signatureData

clearData

)

java.security.PrivateKey

Module Contents

sign

(

bytesToSign

)

sign

(

bytesToSign

publicKey

)

Module Contents

containsAny

(

otherKeys

)

isFulfilledBy

(

otherKey

)

isFulfilledBy

(

otherKeys

)

isValid

(

content

signature

)

keys

toStringShort

(

)

verify

(

content

signature

)

verify

(

signatureData

clearData

)

Module Contents

toBase58String

(

)

toSHA256Bytes

(

)

java.sql.Blob

Module Contents

Blob

deserialize

(

serializationFactory

context

)

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

Issued

Module Contents

fun <V, W>

match

(

success

(

)

failure

(

)

Module Contents

fun <V>

getOrThrow

(

timeout

)

Module Contents

contextLogger

(

)

Module Contents

hashAs

(

algorithm

)

sha256

(

)

Module Contents

deserialize

(

serializationFactory

context

)

Module Contents

sequence

(

offset

size

)

toBase58

(

)

toBase64

(

)

toHex

(

)

toHexString

(

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

days

exactAdd

(

)

hours

millis

minutes

seconds

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

exactAdd

(

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

base58ToByteArray

(

)

base58ToRealString

(

)

base58toBase64

(

)

base58toHex

(

)

base64ToByteArray

(

)

base64ToRealString

(

)

base64toBase58

(

)

base64toHex

(

)

hexToBase58

(

)

hexToBase64

(

)

hexToByteArray

(

)

hexToRealString

(

)

parseAsHex

(

)

Module Contents

requireSingleCommand

(

)

requireSingleCommand

(

klass

)

select

(

signer

party

)

select

(

klass

signer

party

)

select

(

signers

parties

)

select

(

klass

signers

parties

)

Module Contents

fun <T>

toNonEmptySet

(

)

Module Contents

filterStatesOfType

(

)

Module Contents

byKeys

(

)

Module Contents

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

sumObligations

(

)

sumObligationsOrNull

(

)

sumObligationsOrZero

(

issuanceDef

)

kotlin.collections.Map

Module Contents

from

(

session

)

kotlin.reflect.KClass

Module Contents

infix fun <T :

from

(

session

)

package net.corda.client.jackson

Module Contents

object JacksonSupport

Module Contents

object ~~AmountDeserializer~~

Module Contents

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~AmountSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~AnonymousPartyDeserializer~~

Module Contents

object ~~AnonymousPartySerializer~~

Module Contents

generator

provider

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~CordaX500NameDeserializer~~

Module Contents

object ~~CordaX500NameSerializer~~

Module Contents

generator

provider

)

class ~~IdentityObjectMapper~~ :

IdentityObjectMapper(identityService:

Module Contents

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

class ~~NoPartyObjectMapper~~ :

NoPartyObjectMapper(factory: <ERROR CLASS>, isFullParties:

Module Contents

)

)

)

)

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~NodeInfoDeserializer~~

Module Contents

object ~~NodeInfoSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, ctxt: <ERROR CLASS>):

object ~~OpaqueBytesDeserializer~~

Module Contents

object ~~OpaqueBytesSerializer~~

Module Contents

gen

serializers

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~PartyDeserializer~~

Module Contents

@DoNotImplement interface PartyObjectMapper

Module Contents

abstract val isFullParties:

)

)

abstract fun partyFromKey(owningKey:

)

)

object ~~PartySerializer~~

Module Contents

gen

provider

)

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

object ~~PublicKeyDeserializer~~

Module Contents

object ~~PublicKeySerializer~~

Module Contents

generator

provider

)

class ~~RpcObjectMapper~~ :

Module Contents

RpcObjectMapper(rpc:

factory

fuzzyIdentityMatch

isFullParties

)

)

)

)

)

class ~~SecureHashDeserializer~~<T :

fun deserialize(parser: <ERROR CLASS>, context: <ERROR CLASS>):

Module Contents

SecureHashDeserializer()

object ~~SecureHashSerializer~~

Module Contents

generator

provider

)

abstract class ~~SignedTransactionMixin~~

Module Contents

SignedTransactionMixin()

abstract fun getId():

abstract fun getInputs():

abstract fun getNotary():

abstract fun getNotaryChangeTx():

abstract fun getRequiredSigningKeys():

protected abstract fun getSigs():

protected abstract fun getTransaction():

abstract fun getTx():

abstract fun getTxBits():

object ~~ToStringSerializer~~

Module Contents

generator

provider

)

abstract fun getAvailableComponentHashes():

abstract class ~~WireTransactionMixin~~

Module Contents

WireTransactionMixin()

abstract fun getAvailableComponents():

abstract fun getMerkleTree():

abstract fun getOutputStates():

fun createDefaultMapper(rpc:

val ~~cordaModule~~: <ERROR CLASS>

factory

fuzzyIdentityMatch

fullParties

fun createInMemoryMapper(identityService:

)

factory

fuzzyIdentityMatch

fullParties

fun createNonRpcMapper(factory: <ERROR CLASS> = JsonFactory(), fullParties:

)

open class StringToMethodCallParser<in T :

)

Module Contents

out

)

inner class ParsedMethodCall<in T :

out

)

Callable

Module Contents

ParsedMethodCall(target:

method

args

)

operator fun invoke():

val method:

open class UnparseableCallException :

UnparseableCallException(command:

Module Contents

cause

)

class FailedParse :

Module Contents

FailedParse(e:

)

class MissingParameter :

MissingParameter(methodName:

Module Contents

paramName

command

)

Module Contents

NoSuchFile(filename:

class ReflectionDataMissing :

)

ReflectionDataMissing(methodName:

Module Contents

argIndex

class TooManyParameters :

)

TooManyParameters(methodName:

Module Contents

command

)

class UnknownMethod :

UnknownMethod(methodName:

Module Contents

)

val methodName:

val availableCommands:

protected val methodMap: <ERROR CLASS><

open fun paramNamesFromConstructor(ctor:

val methodParamNames:

Constructor

)

open fun paramNamesFromMethod(method:

)

command

)

fun parseArguments(methodNameHint:

parameters

args

)

fun validateIsMatchingCtor(methodNameHint:

parameters

args

)

package net.corda.client.rpc

Module Contents

open class ConnectionFailureException :

ConnectionFailureException(cause:

Module Contents

)

class CordaRPCClient

Module Contents

configuration

)

configuration

classLoader

)

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

)

configuration

sslConfiguration

classLoader

customSerializers

)

configuration

sslConfiguration

classLoader

customSerializers

@CordaInternal @VisibleForTesting fun getRegisteredCustomSerializers():

)

inline fun <A> use(username:

password

gracefulReconnect

)

password

targetLegalIdentity

gracefulReconnect

)

password

externalTrace

impersonatedActor

gracefulReconnect

)

password

externalTrace

impersonatedActor

targetLegalIdentity

gracefulReconnect

)

password

open class CordaRPCClientConfiguration

block

(

CordaRPCConnection

)

Module Contents

CordaRPCClientConfiguration(connectionMaxRetryInterval:

minimumServerProtocolVersion

trackRpcCallSites

reapInterval

observationExecutorPoolSize

connectionRetryInterval

connectionRetryIntervalMultiplier

maxReconnectAttempts

maxFileSize

deduplicationCacheExpiry

)

val DEFAULT:

operator fun ~~component1~~():

open val connectionMaxRetryInterval:

open val connectionRetryInterval:

open val connectionRetryIntervalMultiplier:

open val deduplicationCacheExpiry:

)

open val maxFileSize:

open val maxReconnectAttempts:

open val minimumServerProtocolVersion:

open val observationExecutorPoolSize:

open val reapInterval:

open val trackRpcCallSites:

class CordaRPCConnection :

Module Contents

fun notifyServerAndClose():

val proxy:

val serverProtocolVersion:

GracefulReconnect(onDisconnect:

class GracefulReconnect

Module Contents

onReconnect

maxAttempts

GracefulReconnect(onDisconnect: () ->

)

onReconnect

(

)

maxAttempts

)

val onDisconnect: () ->

val onReconnect: () ->

class MaxRpcRetryException :

MaxRpcRetryException(maxNumberOfRetries:

Module Contents

method

cause

class PermissionException :

)

ClientRelevantError

Module Contents

PermissionException(msg:

)

val msg:

@DoNotImplement interface RPCConnection<out I :

Module Contents

abstract fun forceClose():

abstract fun notifyServerAndClose():

abstract val serverProtocolVersion:

abstract val proxy:

open class RPCException :

Module Contents

RPCException(msg:

)

RPCException(message:

cause

@Target([AnnotationTarget.FUNCTION]) annotation class RPCSinceVersion

)

Module Contents

RPCSinceVersion(version:

)

open class UnrecoverableRPCException :

UnrecoverableRPCException(message:

Module Contents

cause

)

fun <T> <ERROR CLASS><

notUsed

(

)

package net.corda.client.rpc.ext

Module Contents

class MultiRPCClient<I :

Module Contents

rpcOpsClass

username

password

configuration

)

rpcOpsClass

username

password

classLoader

configuration

)

rpcOpsClass

username

password

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

configuration

sslConfiguration

classLoader

)

rpcOpsClass

username

password

customSerializers

configuration

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

rpcOpsClass

username

password

customSerializers

configuration

fun addConnectionListener(listener:

sslConfiguration

classLoader

externalTrace

impersonatedActor

targetLegalIdentity

)

)

fun close():

fun removeConnectionListener(listener:

interface RPCConnectionListener<I :

)

interface ConnectionContext<I :

Module Contents

abstract val connectionOpt:

Module Contents

RPCConnection

abstract val throwableOpt:

abstract val userName:

abstract fun onConnect(context:

)

abstract fun onDisconnect(context:

)

abstract fun onPermanentFailure(context:

)

package net.corda.client.rpc.reconnect

Module Contents

class CouldNotStartFlowException :

CouldNotStartFlowException(cause:

Module Contents

open class CordaException :

)

package net.corda.core

Module Contents

interface ~~ClientRelevantError~~

Module Contents

cause

)

)

)

)

)

const val ALIAS_PRIVATE_KEY:

)

Module Contents

Module Contents

const val CORDA_PLATFORM:

const val R3_ROOT:

const val X509_EXTENSION_CORDA_ROLE:

open class CordaRuntimeException :

RuntimeException

Module Contents

cause

)

CordaRuntimeException(originalExceptionClassName:

)

_message

_cause

)

)

)

)

)

abstract fun addSuppressed(suppressed:

interface CordaThrowable

Module Contents

)

abstract var originalExceptionClassName:

abstract val originalMessage:

abstract fun setCause(cause:

)

abstract fun setMessage(message:

)

@Target([AnnotationTarget.CLASS]) @Inherited annotation class DoNotImplement

Module Contents

DeleteForDJVM()

Module Contents

DoNotImplement()

@Target([AnnotationTarget.FILE, AnnotationTarget.CLASS]) @CordaInternal annotation class KeepForDJVM

Module Contents

KeepForDJVM()

@Target([AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER]) @CordaInternal annotation class StubOutForDJVM

Module Contents

StubOutForDJVM()

fun <SNAPSHOT, ELEMENT>

SNAPSHOT

doOnError

(

action

(

)

)

fun <SNAPSHOT, ELEMENT>

SNAPSHOT

fun <ELEMENT> <ERROR CLASS><

mapErrors

(

transform

(

)

)

mapErrors

(

transform

(

)

)

fun <T> <ERROR CLASS><

toFuture

(

)

fun <A>

package net.corda.core.concurrent

out

toObservable

(

)

Module Contents

interface CordaFuture<V> :

abstract fun <W> then(callback: (

Module Contents

)

abstract fun toCompletableFuture():

fun <V, W> firstOf(vararg futures:

out

handler

(

out

)

Module Contents

fun <V, W>

match

(

success

(

)

failure

(

package net.corda.core.context

)

Module Contents

Module Contents

serviceId

owningLegalIdentity

)

Module Contents

)

data class InvocationContext

owningLegalIdentity

)

data class AuthServiceId

Module Contents

)

Module Contents

trace

actor

externalTrace

impersonatedActor

)

fun scheduled(scheduledState:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

trace

actor

externalTrace

impersonatedActor

)

val impersonatedActor:

Actor

fun newInstance(origin:

trace

actor

externalTrace

impersonatedActor

arguments

clientId

)

trace

externalTrace

impersonatedActor

)

trace

externalTrace

impersonatedActor

arguments

)

trace

externalTrace

)

sealed class InvocationOrigin

owningLegalIdentity

trace

externalTrace

)

externalTrace

)

Module Contents

Module Contents

)

Module Contents

)

InvocationOrigin

Module Contents

)

Module Contents

owningLegalIdentity

)

fun principal():

Principal

abstract fun principal():

Module Contents

Module Contents

sessionId

)

Module Contents

timestamp

)

timestamp

)

Module Contents

timestamp

)

fun newInstance(invocationId:

timestamp

)

sessionId

)

package net.corda.core.contracts

Module Contents

object AlwaysAcceptAttachmentConstraint :

Module Contents

)

data class Amount<T :

Module Contents

Amount(tokenQuantity:

token

)

Amount(quantity:

displayTokenSize

token

)

fromDecimal

(

displayQuantity

token

rounding

RoundingMode

)

fun getDisplayTokenSize(token:

)

operator fun minus(other:

)

fun parseCurrency(input:

)

fun splitEvenly(partitions:

)

)

sumOrNull

(

)

sumOrThrow

(

)

sumOrZero

(

token

)

)

)

zero

(

token

)

class AmountTransfer<T :

AmountTransfer(quantityDelta:

Module Contents

token

source

destination

)

newRef

)

)

fromDecimal

(

displayQuantityDelta

token

source

destination

rounding

)

fun novate(centralParty:

)

)

zero

(

token

source

destination

)

@DoNotImplement interface Attachment :

open fun extractFile(path:

Module Contents

outputTo

)

open fun openAsJAR():

JarInputStream

abstract val signerKeys:

@DoNotImplement interface AttachmentConstraint

abstract val ~~signers~~:

Module Contents

abstract fun isSatisfiedBy(attachment:

)

AttachmentResolutionException(hash:

Module Contents

)

object ~~AutomaticHashConstraint~~ :

Module Contents

)

object AutomaticPlaceholderConstraint :

Module Contents

)

@Target([AnnotationTarget.CLASS]) annotation class BelongsToContract

Module Contents

BelongsToContract(value:

out

)

out

class BrokenAttachmentException :

BrokenAttachmentException(attachmentId:

Module Contents

message

cause

)

data class Command<T :

Module Contents

key

)

signers

)

data class CommandAndState

Module Contents

CommandAndState(command:

ownableState

)

interface CommandData

data class CommandWithParties<out T :

CommandWithParties(signers:

Module Contents

signingParties

value

)

val signers:

val ~~signingParties~~:

enum class ComponentGroupEnum

val value:

Module Contents

Module Contents

abstract fun verify(tx:

)

class ContractAttachment :

ContractAttachment(attachment:

Module Contents

contract

additionalContracts

uploader

)

val additionalContracts:

@CordaInternal fun create(attachment:

contract

additionalContracts

uploader

signerKeys

version

)

typealias ContractClassName =

abstract val participants:

interface ContractState

Module Contents

interface FungibleAsset<T :

Module Contents

abstract val exitKeys:

abstract fun withNewOwnerAndAmount(newAmount:

newOwner

)

interface FungibleState<T :

Module Contents

data class HashAttachmentConstraint :

HashAttachmentConstraint(attachmentId:

Module Contents

)

val attachmentId:

val disableHashConstraints:

)

class InsufficientBalanceException :

InsufficientBalanceException(amountMissing:

Module Contents

)

val amountMissing:

data class Issued<out P :

Module Contents

Issued(issuer:

@Target([AnnotationTarget.CLASS]) annotation class LegalProseReference

product

)

Module Contents

LegalProseReference(uri:

)

val uri:

class LinearPointer<T :

Module Contents

type

)

type

isResolved

)

)

)

)

interface LinearState :

Module Contents

abstract val linearId:

const val MAX_ISSUER_REF_SIZE:

interface MoveCommand :

Module Contents

abstract val contract:

out

interface NamedByHash

Module Contents

@Target([AnnotationTarget.CLASS]) @Inherited annotation class NoConstraintPropagation

Module Contents

NoConstraintPropagation()

interface OwnableState :

Module Contents

abstract val owner:

abstract fun withNewOwner(newOwner:

)

data class PartyAndReference

Module Contents

PartyAndReference(party:

reference

)

Module Contents

PrivacySalt(saltLength:

)

)

fun createFor(algorithm:

)

data class ReferencedStateAndRef<out T :

ReferencedStateAndRef(stateAndRef:

Module Contents

)

Module Contents

using

(

expr

)

interface SchedulableState :

abstract fun nextScheduledActivity(thisStateRef:

Module Contents

flowLogicRefFactory

)

Module Contents

abstract val scheduledAt:

data class ScheduledActivity :

ScheduledActivity(logicRef:

Module Contents

scheduledAt

)

data class ScheduledStateRef :

data class SignatureAttachmentConstraint :

Module Contents

ScheduledStateRef(ref:

scheduledAt

)

SignatureAttachmentConstraint(key:

Module Contents

)

data class SourceAndAmount<T :

)

out

data class StateAndContract

Module Contents

SourceAndAmount(source:

amount

ref

)

Module Contents

StateAndContract(state:

contract

)

data class StateAndRef<out T :

Module Contents

ref

)

val state:

@DoNotImplement sealed class StatePointer<T :

Module Contents

abstract val isResolved:

linearPointer

(

state

isResolved

)

abstract val pointer:

abstract fun resolve(services:

)

abstract fun resolve(ltx:

)

staticPointer

(

stateAndRef

isResolved

)

Module Contents

index

)

class StaticPointer<T :

Module Contents

type

)

type

isResolved

)

)

abstract class TimeWindow

)

)

Module Contents

TimeWindow()

fun between(fromTime:

untilTime

)

abstract operator fun contains(instant:

)

fun fromOnly(fromTime:

)

fun fromStartAndDuration(fromTime:

duration

)

abstract val fromTime:

val length:

abstract val midpoint:

fun untilOnly(untilTime:

)

abstract val untilTime:

fun withTolerance(instant:

tolerance

)

interface TokenizableAssetInfo

Module Contents

abstract val displayTokenSize:

open class TransactionResolutionException :

TransactionResolutionException(hash:

Module Contents

message

class UnknownParametersException :

)

TransactionResolutionException

Module Contents

UnknownParametersException(txId:

paramsHash

)

data class TransactionState<out T :

abstract class TransactionVerificationException :

Module Contents

TransactionState(data:

contract

notary

encumbrance

constraint

)

TransactionVerificationException(txId:

Module Contents

message

cause

class BrokenTransactionException :

)

BrokenTransactionException(txId:

Module Contents

message

class ConflictingAttachmentsRejection :

)

ConflictingAttachmentsRejection(txId:

Module Contents

contractClass

)

class ConstraintPropagationRejection :

Module Contents

contractClass

inputConstraint

outputConstraint

)

class ContractConstraintRejection :

message

)

ContractConstraintRejection(txId:

Module Contents

contractClass

)

class ContractCreationError :

Module Contents

val contractClass:

class ContractRejection :

class DuplicateAttachmentsRejection :

Module Contents

Module Contents

DuplicateAttachmentsRejection(txId:

Module Contents

attachmentId

)

class InvalidAttachmentException :

InvalidAttachmentException(txId:

Module Contents

attachmentHash

)

class InvalidConstraintRejection :

InvalidConstraintRejection(txId:

Module Contents

contractClass

reason

)

class MissingAttachmentRejection :

MissingAttachmentRejection(txId:

Module Contents

contractClass

)

class MissingNetworkParametersException :

Module Contents

missingNetworkParametersHash

)

message

class NotaryChangeInWrongTransactionType :

)

NotaryChangeInWrongTransactionType(txId:

Module Contents

txNotary

outputNotary

)

class OverlappingAttachmentsException :

OverlappingAttachmentsException(txId:

Module Contents

path

)

class PackageOwnershipException :

PackageOwnershipException(txId:

Module Contents

attachmentHash

invalidClassName

packageName

)

val invalidClassName:

val packageName:

class TransactionContractConflictException :

Module Contents

state

requiredContractClassName

)

message

class TransactionDuplicateEncumbranceException :

)

Module Contents

index

)

message

class TransactionMissingEncumbranceException :

)

TransactionMissingEncumbranceException(txId:

Module Contents

missing

inOut

)

class TransactionNetworkParameterOrderingException :

Module Contents

inputStateRef

txnNetworkParameters

inputNetworkParameters

)

message

class TransactionNonMatchingEncumbranceException :

)

Module Contents

nonMatching

)

message

class TransactionNotaryMismatchEncumbranceException :

)

TransactionNotaryMismatchEncumbranceException(txId:

Module Contents

encumberedIndex

encumbranceIndex

encumberedNotary

encumbranceNotary

)

TransactionNotaryMismatchEncumbranceException(txId:

message

class TransactionRequiredContractUnspecifiedException :

)

TransactionRequiredContractUnspecifiedException(txId:

Module Contents

state

TransactionRequiredContractUnspecifiedException(txId:

)

message

class UnsupportedClassVersionError :

)

UnsupportedClassVersionError(txId:

Module Contents

message

cause

class UnsupportedHashTypeException :

)

UnsupportedHashTypeException(txId:

Module Contents

class UntrustedAttachmentsException :

)

UntrustedAttachmentsException(txId:

Module Contents

ids

)

abstract class TypeOnlyCommandData :

Module Contents

TypeOnlyCommandData()

)

open fun hashCode(): <ERROR CLASS>

data class UniqueIdentifier :

UniqueIdentifier(externalId:

Module Contents

)

)

)

@VisibleForTesting fun fromString(name:

)

interface UpgradedContract<in OldState :

out

NewState

abstract val legacyContract:

Module Contents

abstract fun upgrade(state:

OldState

)

NewState

interface UpgradedContractWithLegacyConstraint<in OldState :

abstract val legacyContractConstraint:

out

NewState

Module Contents

object WhitelistedByZoneAttachmentConstraint :

Module Contents

)

hash

(

)

hash

(

algorithm

)

Module Contents

requireSingleCommand

(

)

requireSingleCommand

(

klass

)

select

(

signer

party

)

select

(

klass

signer

party

)

select

(

signers

parties

)

select

(

klass

signers

parties

)

Module Contents

filterStatesOfType

(

)

inline fun <R> requireThat(body:

Requirements

(

)

MoveCommand

verifyMoveCommand

(

inputs

commands

)

withoutIssuer

(

)

package net.corda.core.cordapp

Module Contents

@DoNotImplement interface Cordapp

Module Contents

@DoNotImplement interface Info

Module Contents

data class Contract :

Module Contents

vendor

versionId

licence

)

data class ContractAndWorkflow :

Info

Module Contents

ContractAndWorkflow(contract:

workflow

)

Module Contents

vendor

version

licence

)

data class Workflow :

Module Contents

vendor

versionId

licence

)

abstract fun hasUnknownFields():

abstract val licence:

abstract val shortName:

abstract val vendor:

abstract val version:

abstract val allFlows:

out

abstract val checkpointCustomSerializers:

CheckpointCustomSerializer

abstract val contractClassNames:

abstract val cordappClasses:

abstract val customSchemas:

abstract val initiatedFlows:

out

abstract val jarHash:

abstract val jarPath:

abstract val minimumPlatformVersion:

abstract val name:

abstract val rpcFlows:

out

abstract val schedulableFlows:

out

abstract val serializationCustomSerializers:

abstract val serializationWhitelists:

abstract val serviceFlows:

SerializationWhitelist

out

out

abstract val targetPlatformVersion:

@DoNotImplement interface CordappConfig

Module Contents

abstract fun exists(path:

)

abstract fun get(path:

)

abstract fun getBoolean(path:

)

abstract fun getDouble(path:

)

abstract fun getFloat(path:

abstract fun getInt(path:

)

Float

)

abstract fun getLong(path:

)

abstract fun getNumber(path:

abstract fun getString(path:

)

Number

)

class CordappConfigException :

CordappConfigException(msg:

Module Contents

@CordaInternal fun create(cordapp:

)

class CordappContext

Module Contents

CordappContext(cordapp:

attachmentId

classLoader

)

attachmentId

classLoader

config

)

data class CordappInfo

Module Contents

name

shortName

minimumPlatformVersion

targetPlatformVersion

version

vendor

licence

jarHash

)

val targetPlatformVersion:

@DoNotImplement interface CordappProvider

Module Contents

abstract fun getAppContext():

abstract fun getContractAttachmentID(contractClassName:

)

package net.corda.core.crypto

Module Contents

Module Contents

Module Contents

weight

)

fun addKeys(vararg keys:

)

)

)

const val KEY_ALGORITHM:

data class NodeAndWeight :

Module Contents

weight

)

)

fun toASN1Primitive(): <ERROR CLASS>

)

fun getFormat(): <ERROR CLASS>

fun getInstance(encoded:

fun getInstance(asn1: <ERROR CLASS>):

)

fun hashCode():

fun isFulfilledBy(key:

fun isFulfilledBy(keysToCheck:

)

)

class CompositeKeyFactory :

KeyFactorySpi

Module Contents

CompositeKeyFactory()

protected fun engineGeneratePrivate(keySpec:

KeySpec

)

protected fun engineGeneratePublic(keySpec:

)

engineGetKeySpec

(

key

keySpec

protected fun engineTranslateKey(key:

)

)

class CompositeSignature :

Signature

Module Contents

CompositeSignature()

const val SIGNATURE_ALGORITHM:

data class State

Module Contents

State(buffer:

verifyKey

CompositeKey

)

val buffer:

fun engineVerify(sigBytes:

)

protected fun ~~engineGetParameter~~(param:

)

protected fun engineInitSign(privateKey:

)

protected fun engineInitVerify(publicKey:

)

protected fun ~~engineSetParameter~~(param:

value

)

protected fun engineSetParameter(params:

)

protected fun engineSign():

)

protected fun engineVerify(sigBytes:

off

len

)

)

fun getService(provider:

data class CompositeSignaturesWithKeys

)

Service

Module Contents

CompositeSignaturesWithKeys(sigs:

CompositeSignaturesWithKeys

)

val EMPTY:

object CordaObjectIdentifier

Module Contents

val COMPOSITE_KEY: <ERROR CLASS>

val COMPOSITE_SIGNATURE: <ERROR CLASS>

class CordaSecurityProvider :

val DEFAULT_SIGNATURE_SCHEME:

Module Contents

CordaSecurityProvider()

const val PROVIDER_NAME:

algorithm

)

Module Contents

val ECDSA_SECP256K1_SHA256:

val ECDSA_SECP256R1_SHA256:

val EDDSA_ED25519_SHA512:

val RSA_SHA256:

val SHA512_256: <ERROR CLASS>

val SPHINCS256_SHA256:

fun decodePrivateKey(encodedKey:

)

fun decodePrivateKey(schemeCodeName:

encodedKey

)

fun decodePrivateKey(signatureScheme:

encodedKey

)

fun decodePublicKey(encodedKey:

)

fun decodePublicKey(schemeCodeName:

encodedKey

)

fun decodePublicKey(signatureScheme:

encodedKey

)

fun deriveKeyPair(signatureScheme:

privateKey

seed

)

fun deriveKeyPair(privateKey:

seed

)

fun deriveKeyPairFromEntropy(signatureScheme:

entropy

)

fun deriveKeyPairFromEntropy(entropy:

)

fun doSign(privateKey:

clearData

)

fun doSign(schemeCodeName:

privateKey

clearData

)

fun doSign(signatureScheme:

privateKey

clearData

)

signableData

)

fun doVerify(schemeCodeName:

publicKey

signatureData

clearData

)

fun doVerify(publicKey:

signatureData

clearData

)

fun doVerify(signatureScheme:

publicKey

signatureData

clearData

)

transactionSignature

)

fun findProvider(name:

)

fun findSignatureScheme(algorithm: <ERROR CLASS>):

fun findSignatureScheme(schemeNumberID:

)

fun findSignatureScheme(schemeCodeName:

)

)

)

fun generateKeyPair(schemeCodeName:

)

fun generateKeyPair(signatureScheme:

)

fun isSupportedSignatureScheme(signatureScheme:

)

transactionSignature

)

fun isValid(publicKey:

signatureData

clearData

)

fun isValid(signatureScheme:

publicKey

signatureData

clearData

)

fun publicKeyOnCurve(signatureScheme:

publicKey

)

fun registerProviders():

fun supportedSignatureSchemes():

fun toSupportedPrivateKey(key:

)

fun toSupportedPublicKey(key: <ERROR CLASS>):

fun toSupportedPublicKey(key:

)

fun validatePublicKey(key:

)

interface DigestAlgorithm

Module Contents

abstract val algorithm:

open fun componentDigest(bytes:

)

abstract fun digest(bytes:

)

abstract val digestLength:

open fun nonceDigest(bytes:

)

DigestService(hashAlgorithm:

data class DigestService

Module Contents

)

val allOnesHash:

fun componentHash(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun componentHash(nonce:

opaqueBytes

)

fun computeNonce(privacySalt:

groupIndex

internalIndex

)

)

)

serializedHash

(

)

open class DigitalSignature :

object DummySecureRandom :

Module Contents

DigitalSignature(bytes:

)

Module Contents

bytes

)

)

)

)

SecureRandom

sealed class MerkleTree

Module Contents

Module Contents

)

Module Contents

left

right

)

)

class MerkleTreeException :

nodeDigestService

)

MerkleTreeException(reason:

Module Contents

)

Module Contents

object NullPublicKey :

Module Contents

)

class PartialMerkleTree

Module Contents

PartialMerkleTree(root:

PartialTree

)

sealed class PartialTree

Module Contents

data class IncludedLeaf :

Module Contents

)

Module Contents

)

Module Contents

right

)

right

hashAlgorithm

)

right

)

fun build(merkleRoot:

includeHashes

)

@CordaInternal fun leafIndex(leaf:

)

fun rootAndUsedHashes(node:

usedHashes

)

fun verify(merkleRootHash:

hashesToCheck

)

sealed class SecureHash :

Module Contents

Module Contents

bytes

)

)

)

Module Contents

)

)

fun allOnesHashFor(algorithm:

)

)

fun componentHashAs(algorithm:

bytes

)

fun concatenate(other:

)

fun concatenateAs(concatAlgorithm:

other

)

)

fun digestLengthFor(algorithm:

)

protected open fun generate(data:

)

fun getAllOnesHash():

fun getZeroHash():

fun hashAs(algorithm:

bytes

)

fun hashConcat(other:

fun nonceHashAs(algorithm:

)

bytes

)

)

fun prefixChars(prefixLen:

fun zeroHashFor(algorithm:

)

fun random(algorithm:

)

)

)

fun sha256Twice(bytes:

)

)

data class SignableData

Module Contents

SignableData(txId:

signatureMetadata

)

val txId:

data class SignatureMetadata

Module Contents

SignatureMetadata(platformVersion:

schemeNumberID

)

data class SignatureScheme

Module Contents

SignatureScheme(schemeNumberID:

schemeCodeName

signatureOID

alternativeOIDs

providerName

algorithmName

signatureName

algSpec

keySize

desc

)

val algSpec:

val signatureOID: <ERROR CLASS>

open class SignedData<T :

Module Contents

sig

)

protected open fun verifyData(data:

)

class TransactionSignature :

DigitalSignature

Module Contents

signatureMetadata

)

signatureMetadata

partialMerkleTree

)

)

)

)

algorithm

fun ~~componentHash~~(opaqueBytes:

privacySalt

componentGroupIndex

internalIndex

)

fun ~~componentHash~~(nonce:

opaqueBytes

)

fun entropyToKeyPair(entropy:

fun ~~computeNonce~~(privacySalt:

groupIndex

internalIndex

)

)

fun generateKeyPair():

hashAs

(

algorithm

)

isZero

java.security.KeyPair

Module Contents

component1

(

)

component2

(

)

sign

(

bytesToSign

)

sign

(

bytesToSign

)

sign

(

signableData

)

verify

(

signatureData

clearData

)

java.security.PrivateKey

Module Contents

sign

(

bytesToSign

)

sign

(

bytesToSign

publicKey

)

Module Contents

containsAny

(

otherKeys

)

isFulfilledBy

(

otherKey

)

isFulfilledBy

(

otherKeys

)

isValid

(

content

signature

)

keys

toStringShort

(

)

verify

(

content

signature

)

verify

(

signatureData

clearData

)

Module Contents

hashAs

(

algorithm

)

sha256

(

)

Module Contents

byKeys

(

)

fun newSecureRandom():

SecureRandom

fun random63BitValue():

DigestService

randomHash

(

)

fun secureRandomBytes(numOfBytes:

)

~~serializedHash~~

(

)

sha256

(

)

package net.corda.core.flows

Module Contents

abstract class AbstractStateReplacementFlow

Module Contents

AbstractStateReplacementFlow()

abstract class Acceptor<in T> :

Module Contents

)

progressTracker

)

val initiatingSession:

protected abstract fun verifyProposal(stx:

proposal

Proposal

)

abstract class Instigator<out S :

out

out

Module Contents

Instigator(originalState:

protected abstract fun assembleTx():

modification

progressTracker

)

open fun getParticipantSessions():

data class Proposal<out M>

Module Contents

Proposal(stateRef:

class CollectSignatureFlow :

modification

)

Module Contents

)

Module Contents

session

vararg

signingKeys

)

session

signingKeys

)

class CollectSignaturesFlow :

Module Contents

sessionsToCollectFrom

progressTracker

)

sessionsToCollectFrom

myOptionalKeys

progressTracker

)

val progressTracker:

val sessionsToCollectFrom:

object ContractUpgradeFlow

Module Contents

@StartableByRPC class Authorise :

Module Contents

Authorise(stateAndRef:

@StartableByRPC class Deauthorise :

upgradedContractClass

out

)

@InitiatingFlow @StartableByRPC class Initiate<OldState :

Module Contents

Deauthorise(stateRef:

)

out

NewState

out

Module Contents

Initiate(originalState:

newContractClass

out

)

open class DataVendingFlow :

DataVendingFlow(otherSideSession:

Module Contents

payload

)

val payload:

protected open fun sendPayloadAndReceiveDataRequest(otherSideSession:

payload

)

protected open fun verifyDataRequest(dataRequest: Data):

Request

@DoNotImplement interface Destination

@InitiatingFlow class FinalityFlow :

Module Contents

extraRecipients

progressTracker

)

extraRecipients

)

)

progressTracker

)

firstSession

vararg

restSessions

)

sessions

progressTracker

)

sessions

statesToRecord

progressTracker

)

sessions

oldParticipants

progressTracker

)

object BROADCASTING :

@CordaInternal data class ExtraConstructorArgs

Module Contents

ExtraConstructorArgs(oldParticipants:

sessions

newApi

statesToRecord

)

Module Contents

@CordaInternal fun getExtraConstructorArgs():

open class FlowException :

Module Contents

cause

)

)

)

cause

originalErrorId

)

open fun getErrorId():

var originalErrorId:

interface FlowExternalAsyncOperation<R :

Module Contents

)

interface FlowExternalOperation<R :

Module Contents

sealed class FlowInitiator :

)

data class FlowInfo

Module Contents

FlowInfo(flowVersion:

appName

)

Module Contents

Module Contents

)

Module Contents

)

FlowInitiator

Module Contents

)

Module Contents

)

fun getName():

Module Contents

abstract class FlowLogic<out T>

Module Contents

FlowLogic()

FlowExternalAsyncOperation

await

(

operation

)

fun checkFlowIsNotKilled():

await

(

operation

FlowExternalOperation

)

abstract fun call():

fun checkFlowIsNotKilled(lazyMessage: () ->

)

fun checkFlowPermission(permissionName:

extraAuditData

)

)

fun flowStackSnapshot():

FlowStackSnapshot

fun ~~getFlowInfo~~(otherParty:

)

fun initiateFlow(destination:

)

val logger: <ERROR CLASS>

fun initiateFlow(party:

)

val ourIdentity:

val ourIdentityAndCert:

fun persistFlowStackSnapshot():

open fun receiveAllMap(sessions:

~~receive~~

(

otherParty

)

~~receive~~

(

receiveType

otherParty

)

receiveAll

(

receiveType

sessions

maySkipCheckpoint

)

out

maySkipCheckpoint

)

fun recordAuditEvent(eventType:

comment

extraAuditData

)

open fun ~~send~~(otherParty:

payload

)

sessions

maySkipCheckpoint

)

fun sendAllMap(payloadsPerSession:

maySkipCheckpoint

)

open fun <R> subFlow(subLogic:

~~sendAndReceive~~

(

otherParty

payload

)

~~sendAndReceive~~

(

receiveType

otherParty

payload

)

maySkipCheckpoint

)

)

fun trackStepsTree():

fun trackStepsTreeIndex():

fun waitForLedgerCommit(hash:

maySkipCheckpoint

)

fun waitForStateConsumption(stateRefs:

)

@DoNotImplement interface FlowLogicRef

@DoNotImplement interface FlowLogicRefFactory

Module Contents

abstract fun create(flowClass:

out

vararg

args

)

abstract fun create(flowClassName:

vararg

args

)

abstract fun toFlowLogic(ref:

)

@DoNotImplement abstract class FlowSession

Module Contents

FlowSession()

abstract val counterparty:

abstract val destination:

abstract fun getCounterpartyFlowInfo(maySkipCheckpoint:

)

abstract fun getCounterpartyFlowInfo():

receive

(

)

abstract fun <R :

receive

(

receiveType

maySkipCheckpoint

)

receive

(

receiveType

)

maySkipCheckpoint

)

)

sendAndReceive

(

payload

)

sendAndReceive

(

receiveType

payload

maySkipCheckpoint

)

sendAndReceive

(

receiveType

payload

)

data class FlowStackSnapshot

Module Contents

FlowStackSnapshot(time:

flowClass

stackFrames

)

Module Contents

Frame(stackTraceElement:

stackObjects

)

val stackTraceElement:

open class HospitalizeFlowException :

Module Contents

HospitalizeFlowException(cause:

)

HospitalizeFlowException()

)

cause

class IllegalFlowLogicException :

)

IllegalArgumentException

Module Contents

msg

)

@Target([AnnotationTarget.CLASS]) annotation class InitiatedBy

msg

)

Module Contents

out

)

out

@Target([AnnotationTarget.CLASS]) @Inherited annotation class InitiatingFlow

Module Contents

InitiatingFlow(version:

)

class KilledFlowException :

Module Contents

)

class MaybeSerializedSignedTransaction :

message

)

MaybeSerializedSignedTransaction(id:

Module Contents

serialized

nonSerialised

)

fun payloadContentDescription():

fun serializedByteCount():

data class NotarisationPayload

Module Contents

NotarisationPayload(transaction:

requestSignature

)

val coreTransaction:

val requestSignature:

val signedTransaction:

val transaction:

class NotarisationRequest

Module Contents

NotarisationRequest(statesToConsume:

transactionId

)

data class NotarisationRequestSignature

Module Contents

NotarisationRequestSignature(digitalSignature:

platformVersion

)

val digitalSignature:

val platformVersion:

data class NotarisationResponse

Module Contents

NotarisationResponse(signatures:

)

@InitiatingFlow class NotaryChangeFlow<out T :

Instigator

NotaryChangeFlow(originalState:

Module Contents

newNotary

progressTracker

)

sealed class NotaryError

Module Contents

data class Conflict :

Module Contents

consumedStates

)

val consumedStates:

Module Contents

)

const val NUM_STATES:

data class RequestSignatureInvalid :

RequestSignatureInvalid(cause:

Module Contents

)

data class TimeWindowInvalid :

TimeWindowInvalid(currentTime:

Module Contents

txTimeWindow

data class TransactionInvalid :

)

val ~~INSTANCE~~:

TransactionInvalid(cause:

Module Contents

)

object ~~WrongNotary~~ :

class NotaryException :

@DoNotImplement @InitiatingFlow class Client : BackpressureAwareTimedFlow<

Module Contents

NotaryException(error:

txId

)

Module Contents

Module Contents

skipVerification

)

progressTracker

)

progressTracker

skipVerification

)

protected fun checkTransaction():

open val isTimeoutEnabled:

protected fun notarise(notaryParty:

)

NotarisationResponse

protected fun validateResponse(response:

notaryParty

)

class ReceiveFinalityFlow :

ReceiveFinalityFlow(otherSideSession:

Module Contents

expectedTxId

statesToRecord

)

class ReceiveStateAndRefFlow<out T :

Module Contents

ReceiveStateAndRefFlow(otherSideSession:

)

open class ReceiveTransactionFlow :

ReceiveTransactionFlow(otherSideSession:

Module Contents

protected open fun checkBeforeRecording(stx:

checkSufficientSignatures

statesToRecord

)

)

class ResultSerializationException :

ResultSerializationException(e: MissingSerializerException)

Module Contents

@Target([AnnotationTarget.CLASS]) @Inherited annotation class SchedulableFlow

Module Contents

SchedulableFlow()

open class SendStateAndRefFlow :

SendStateAndRefFlow(otherSideSession:

Module Contents

stateAndRefs

open class SendTransactionFlow :

)

SendTransactionFlow(otherSide:

Module Contents

stx

abstract class SignTransactionFlow :

)

SignTransactionFlow(otherSideSession:

Module Contents

progressTracker

)

protected abstract fun checkTransaction(stx:

)

data class StackFrameDataToken

Module Contents

StackFrameDataToken(className:

)

val className:

@Target([AnnotationTarget.CLASS]) annotation class StartableByRPC

Module Contents

StartableByRPC()

@Target([AnnotationTarget.CLASS]) annotation class StartableByService

Module Contents

StartableByService()

data class StateConsumptionDetails

Module Contents

)

type

enum class ConsumedStateType

)

Module Contents

INPUT_STATE

REFERENCE_INPUT_STATE

fun copy(hashOfTransactionId:

)

val hashOfTransactionId:

data class StateMachineRunId

Module Contents

StateMachineRunId(uuid:

)

open class StateReplacementException :

StateReplacementException(message:

Module Contents

cause

class UnexpectedFlowEndException :

)

Module Contents

cause

)

)

data class WaitTimeUpdate

cause

originalErrorId

)

Module Contents

WaitTimeUpdate(waitTime:

)

val waitTime:

class WithReferencedStatesFlow<T :

WithReferencedStatesFlow(progressTracker:

Module Contents

package net.corda.core.identity

flowLogicProducer

(

)

)

Module Contents

@DoNotImplement abstract class AbstractParty :

Module Contents

AbstractParty(owningKey:

)

abstract fun nameOrNull():

)

val owningKey:

abstract fun ref(bytes:

)

fun ref(vararg bytes:

)

class AnonymousParty :

AnonymousParty(owningKey:

Module Contents

)

)

data class CordaX500Name

Module Contents

CordaX500Name(organisation:

organisation

locality

country

)

locality

country

)

organisationUnit

organisation

locality

state

country

)

const val ~~LENGTH_COUNTRY~~:

const val MAX_LENGTH_COMMON_NAME:

const val MAX_LENGTH_LOCALITY:

const val MAX_LENGTH_ORGANISATION:

const val MAX_LENGTH_ORGANISATION_UNIT:

const val MAX_LENGTH_STATE:

)

val organisationUnit:

)

Module Contents

)

owningKey

)

)

class PartyAndCertificate

Module Contents

PartyAndCertificate(certPath:

)

)

fun verify(trustAnchor:

)

fun verify(trustAnchors:

)

fun <T> excludeHostNode(serviceHub:

map

)

fun <T> excludeNotary(map:

stx

)

fun groupAbstractPartyByWellKnownParty(serviceHub:

parties

fun groupAbstractPartyByWellKnownParty(serviceHub:

ignoreUnrecognisedParties

)

parties

)

fun groupPublicKeysByWellKnownParty(serviceHub:

publicKeys

fun groupPublicKeysByWellKnownParty(serviceHub:

ignoreUnrecognisedParties

)

publicKeys

)

fun x500Matches(query:

exactMatch

x500name

)

package net.corda.core.messaging

Module Contents

interface AllPossibleRecipients :

data class ClientRpcSslOptions

Module Contents

ClientRpcSslOptions(trustStorePath:

trustStorePassword

trustStoreProvider

)

val trustStorePassword:

val trustStorePath:

val trustStoreProvider:

interface CordaRPCOps :

abstract fun acceptNewNetworkParameters(parametersHash:

Module Contents

)

abstract fun addVaultTransactionNote(txnId:

txnNote

)

abstract fun attachmentExists(id:

)

abstract fun currentNodeTime():

abstract fun finishedFlowsWithClientIds():

abstract fun finishedFlowsWithClientIdsAsAdmin():

abstract fun getVaultTransactionNotes(txnId:

)

abstract fun isFlowsDrainingModeEnabled():

abstract fun isWaitingForShutdown():

abstract fun killFlow(id:

)

@RPCReturnsObservables abstract fun networkMapFeed():

abstract fun networkMapSnapshot():

@RPCReturnsObservables abstract fun networkParametersFeed():

abstract fun nodeDiagnosticInfo():

ParametersUpdateInfo

NodeDiagnosticInfo

abstract fun nodeInfo():

)

abstract fun notaryIdentities():

abstract fun notaryPartyFromX500Name(x500Name:

)

)

exactMatch

)

)

abstract fun queryAttachments(query:

sorting

)

@RPCReturnsObservables abstract fun <T> reattachFlowWithClientId(clientId:

)

abstract fun refreshNetworkMapCache():

abstract fun registeredFlows():

abstract fun removeClientId(clientId:

)

abstract fun removeClientIdAsAdmin(clientId:

)

abstract fun setFlowsDrainingModeEnabled(enabled:

)

abstract fun shutdown():

@RPCReturnsObservables abstract fun <T> startFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startFlowDynamicWithClientId(clientId:

logicType

out

vararg

args

)

@RPCReturnsObservables abstract fun <T> startTrackedFlowDynamic(logicType:

out

vararg

args

)

@RPCReturnsObservables abstract fun stateMachineRecordedTransactionMappingFeed():

abstract fun stateMachineRecordedTransactionMappingSnapshot():

@RPCReturnsObservables abstract fun stateMachinesFeed():

abstract fun stateMachinesSnapshot():

abstract fun terminate(drainPendingFlows:

)

abstract fun uploadAttachment(jar:

)

abstract fun uploadAttachmentWithMetadata(jar:

uploader

filename

)

vaultQuery

(

contractStateType

out

)

vaultQueryBy

(

criteria

paging

sorting

contractStateType

out

)

vaultQueryByCriteria

(

criteria

contractStateType

out

)

vaultQueryByWithPagingSpec

(

contractStateType

out

criteria

paging

)

vaultQueryByWithSorting

(

contractStateType

out

criteria

sorting

)

vaultTrack

(

contractStateType

out

)

vaultTrackBy

(

criteria

paging

sorting

contractStateType

out

)

vaultTrackByCriteria

(

contractStateType

out

criteria

)

vaultTrackByWithPagingSpec

(

contractStateType

out

criteria

paging

)

vaultTrackByWithSorting

(

contractStateType

@RPCReturnsObservables abstract fun waitUntilNetworkReady():

out

criteria

sorting

)

abstract fun wellKnownPartyFromAnonymous(party:

)

abstract fun wellKnownPartyFromX500Name(x500Name:

)

data class DataFeed<out A, B>

Module Contents

DataFeed(snapshot:

updates

)

val snapshot:

val updates: <ERROR CLASS><

@DoNotImplement interface FlowHandle<A> :

Module Contents

abstract val returnValue:

data class FlowHandleImpl<A> :

Module Contents

returnValue

)

interface FlowHandleWithClientId<A> :

Module Contents

abstract val clientId:

data class FlowHandleWithClientIdImpl<A> :

FlowHandleWithClientIdImpl(id:

Module Contents

returnValue

clientId

)

interface FlowProgressHandle<A> :

Module Contents

abstract val progress: <ERROR CLASS><

abstract val stepsTreeFeed:

abstract val stepsTreeIndexFeed:

data class FlowProgressHandleImpl<A> :

FlowProgressHandleImpl(id:

Module Contents

returnValue

progress

stepsTreeIndexFeed

stepsTreeFeed

)

returnValue

progress

)

FlowProgressHandleImpl

val progress: <ERROR CLASS><

val stepsTreeIndexFeed:

interface MessageRecipientGroup :

interface MessageRecipients

data class ParametersUpdateInfo

Module Contents

ParametersUpdateInfo(hash:

parameters

description

updateDeadline

)

@DoNotImplement interface RPCOps

Module Contents

abstract val protocolVersion:

@Target([AnnotationTarget.FUNCTION]) annotation class RPCReturnsObservables

Module Contents

RPCReturnsObservables()

interface SingleMessageRecipient :

data class StateMachineInfo

Module Contents

flowLogicClassName

initiator

progressTrackerStepAndUpdates

invocationContext

)

flowLogicClassName

initiator

progressTrackerStepAndUpdates

)

val flowLogicClassName:

val ~~initiator~~:

val progressTrackerStepAndUpdates:

data class StateMachineTransactionMapping

Module Contents

StateMachineTransactionMapping(stateMachineRunId:

transactionId

)

val stateMachineRunId:

val transactionId:

sealed class StateMachineUpdate

Module Contents

data class Added :

StateMachineUpdate

Module Contents

Added(stateMachineInfo:

)

val stateMachineInfo:

Module Contents

result

)

~~pendingFlowsCount~~

(

)

inline fun <T, reified R :

startFlow

(

flowConstructor

(

)

inline fun <T, A, reified R :

startFlow

(

flowConstructor

(

)

arg0

)

inline fun <T, A, B, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

)

inline fun <T, A, B, C, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

)

inline fun <T, A, B, C, D, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

inline fun <T, A, B, C, D, E, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

inline fun <T, A, B, C, D, E, F, reified R :

startFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

inline fun <T, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

inline fun <T, A, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

)

inline fun <T, A, B, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

)

inline fun <T, A, B, C, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

)

inline fun <T, A, B, C, D, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

inline fun <T, A, B, C, D, E, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

inline fun <T, A, B, C, D, E, F, reified R :

startFlowWithClientId

(

clientId

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

inline fun <T, reified R :

startTrackedFlow

(

flowConstructor

(

)

inline fun <T, A, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

)

inline fun <T, A, B, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

)

inline fun <T, A, B, C, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

)

inline fun <T, A, B, C, D, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

)

inline fun <T, A, B, C, D, E, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

)

inline fun <T, A, B, C, D, E, F, reified R :

startTrackedFlow

(

flowConstructor

(

)

arg0

arg1

arg2

arg3

arg4

arg5

)

vaultQueryBy

(

criteria

paging

sorting

)

package net.corda.core.node

vaultTrackBy

(

criteria

paging

sorting

)

Module Contents

interface AppServiceHub :

const val SERVICE_PRIORITY_HIGH:

Module Contents

const val SERVICE_PRIORITY_LOW:

const val SERVICE_PRIORITY_NORMAL:

abstract fun register(priority:

abstract val database:

CordaTransactionSupport

observer

ServiceLifecycleObserver

)

open fun <T> register(priority:

func

(

)

abstract fun <T> startFlow(flow:

)

abstract fun <T> startTrackedFlow(flow:

)

@Target([AnnotationTarget.PROPERTY]) annotation class AutoAcceptable

Module Contents

AutoAcceptable()

data class NetworkParameters

Module Contents

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

packageOwnership

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

eventHorizon

)

notaries

maxMessageSize

maxTransactionSize

modifiedTime

epoch

whitelistedContractImplementations

)

val maxTransactionSize:

val whitelistedContractImplementations:

val packageOwnership:

data class NodeDiagnosticInfo

Module Contents

NodeDiagnosticInfo(version:

revision

platformVersion

vendor

cordapps

)

Module Contents

legalIdentitiesAndCerts

platformVersion

serial

)

fun identityAndCertFromX500Name(name:

)

fun identityFromX500Name(name:

)

fun isLegalIdentity(party:

)

fun isLegalIdentity(name:

)

val legalIdentitiesAndCerts:

data class NotaryInfo

Module Contents

validating

)

interface ServiceHub :

Module Contents

publicKey

)

abstract val contractUpgradeService:

)

cordaService

(

type

)

publicKey

)

)

publicKey

)

)

abstract val diagnosticsService:

open fun getAppContext():

abstract fun jdbcSession():

abstract val keyManagementService:

abstract val myInfo:

abstract val networkMapCache:

txs

)

first

vararg

remaining

)

abstract fun recordTransactions(statesToRecord:

txs

)

open fun recordTransactions(first:

vararg

remaining

)

open fun recordTransactions(txs:

)

abstract fun registerUnloadHandler(runOnStop: () ->

)

publicKey

)

)

signingPubKeys

)

toStateAndRef

(

stateRef

)

abstract val validatedTransactions:

abstract val vaultService:

abstract fun <T> withEntityManager(block: <ERROR CLASS>.() ->

)

abstract fun withEntityManager(block:

)

@DoNotImplement interface ServicesForResolution

Module Contents

abstract val attachments:

abstract val cordappProvider:

abstract val identityService:

abstract fun loadContractAttachment(stateRef:

)

abstract fun loadState(stateRef:

)

abstract fun loadStates(stateRefs:

)

abstract val networkParametersService:

open fun specialise(ltx:

)

enum class StatesToRecord

Module Contents

ALL_VISIBLE

NONE

ONLY_RELEVANT

class ZoneVersionTooLowException :

ZoneVersionTooLowException(message:

Module Contents

package net.corda.core.node.services

)

Module Contents

typealias AttachmentFixup = <ERROR CLASS><

typealias AttachmentId =

@DoNotImplement interface AttachmentStorage

Module Contents

abstract fun getLatestContractAttachments(contractClassName:

minContractVersion

)

abstract fun hasAttachment(attachmentId:

)

abstract fun ~~importAttachment~~(jar:

)

abstract fun importAttachment(jar:

uploader

filename

)

abstract fun ~~importOrGetAttachment~~(jar:

)

)

abstract fun queryAttachments(criteria:

sorting

)

open fun queryAttachments(criteria:

)

@DoNotImplement interface ContractUpgradeService

Module Contents

abstract fun getAuthorisedContractUpgrade(ref:

)

abstract fun removeAuthorisedContractUpgrade(ref:

)

abstract fun storeAuthorisedContractUpgrade(ref:

upgradedContractClass

out

UpgradedContract

)

@Target([AnnotationTarget.CLASS]) annotation class CordaService

Module Contents

CordaService()

class CordaServiceCriticalFailureException :

Module Contents

)

cause

@DoNotImplement interface IdentityService

)

Module Contents

open fun assertOwnership(party:

anonymousParty

)

abstract val caCertStore:

CertStore

abstract fun certificateFromKey(owningKey:

)

abstract fun externalIdForPublicKey(publicKey:

)

abstract fun getAllIdentities():

exactMatch

)

)

abstract fun publicKeysForExternalId(externalId:

)

abstract fun registerKey(publicKey:

party

externalId

)

open fun requireWellKnownPartyFromAnonymous(party:

)

abstract val trustAnchor:

abstract fun verifyAndRegisterIdentity(identity:

abstract val trustRoot:

X509Certificate

)

open fun wellKnownPartyFromAnonymous(party:

)

open fun wellKnownPartyFromAnonymous(partyRef:

)

)

@DoNotImplement interface KeyManagementService

Module Contents

abstract fun filterMyKeys(candidateKeys:

)

abstract fun freshKey():

abstract fun freshKey(externalId:

)

revocationEnabled

)

revocationEnabled

externalId

)

abstract fun sign(bytes:

publicKey

)

abstract fun sign(signableData:

SignableData

publicKey

)

const val MAX_CONSTRAINT_DATA_SIZE:

interface NetworkMapCache :

NetworkMapCacheBase

Module Contents

sealed class MapChange

Module Contents

Module Contents

)

data class Modified :

Module Contents

previousNode

)

Module Contents

)

abstract fun getNodeByLegalIdentity(party:

)

@DoNotImplement interface NetworkMapCacheBase

Module Contents

abstract val allNodes:

abstract val changed: <ERROR CLASS><

MapChange

abstract fun getNodeByAddress(address:

)

abstract fun getNodeByLegalName(name:

)

abstract fun getNodesByLegalIdentityKey(identityKey:

)

abstract fun getNodesByLegalName(name:

)

open fun getNotary(name:

)

abstract fun getPartyInfo(party:

)

open fun getPeerByLegalName(name:

)

abstract fun getPeerCertificateByLegalName(name:

)

abstract fun isNotary(party:

)

abstract fun isValidatingNotary(party:

)

abstract val nodeReady:

abstract val notaryIdentities:

@DoNotImplement interface NetworkParametersService

Module Contents

abstract val currentHash:

abstract val defaultHash:

abstract fun lookup(hash:

)

data class DistributedNode :

sealed class PartyInfo

Module Contents

Module Contents

DistributedNode(party:

)

val party:

enum class ServiceLifecycleEvent

data class SingleNode :

Module Contents

addresses

)

Module Contents

STATE_MACHINE_STARTED

@FunctionalInterface interface ServiceLifecycleObserver

Module Contents

abstract fun onServiceLifecycleEvent(event:

)

class StatesNotAvailableException :

StatesNotAvailableException(message:

Module Contents

cause

)

class ~~TimeWindowChecker~~

Module Contents

TimeWindowChecker(clock:

)

val clock:

fun isValid(timeWindow:

)

@DoNotImplement interface TransactionStorage

Module Contents

abstract fun getTransaction(id:

)

abstract fun trackTransaction(id:

)

class UnknownAnonymousPartyException :

UnknownAnonymousPartyException(message:

Module Contents

)

Module Contents

)

data class ConstraintInfo

Module Contents

ConstraintInfo(constraint:

)

Module Contents

fun constraintInfo(type:

data

)

val ~~NoNotaryUpdate~~: <ERROR CLASS>

val ~~NoUpdate~~: <ERROR CLASS>

data class Page<out T :

Module Contents

statesMetadata

totalStatesAvailable

stateTypes

otherResults

)

val totalStatesAvailable:

enum class RelevancyStatus

Module Contents

NOT_RELEVANT

RELEVANT

data class StateMetadata

Module Contents

StateMetadata(ref:

val contractStateClassName:

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

relevancyStatus

constraintInfo

)

fun copy(ref:

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

)

contractStateClassName

recordedTime

consumedTime

status

notary

lockId

lockUpdateTime

relevancyStatus

)

enum class StateStatus

Module Contents

UNCONSUMED

data class Update<U :

Module Contents

produced

flowId

type

references

)

containsType

(

)

class VaultQueryException :

containsType

(

clazz

status

)

produced

flowId

type

)

operator fun plus(rhs:

)

enum class UpdateType

Module Contents

Module Contents

)

cause

@DoNotImplement interface VaultService

)

Module Contents

_queryBy

(

criteria

paging

sorting

contractStateType

out

)

_trackBy

(

criteria

paging

sorting

contractStateType

out

)

abstract fun addNoteToTransaction(txnId:

noteText

)

abstract fun getTransactionNotes(txnId:

)

queryBy

(

contractStateType

out

)

queryBy

(

contractStateType

out

criteria

)

queryBy

(

contractStateType

out

paging

)

queryBy

(

contractStateType

out

criteria

paging

)

queryBy

(

contractStateType

out

criteria

sorting

)

queryBy

(

contractStateType

abstract val rawUpdates: <ERROR CLASS><

out

criteria

paging

sorting

)

abstract fun softLockRelease(lockId:

stateRefs

)

abstract fun softLockReserve(lockId:

stateRefs

)

trackBy

(

contractStateType

out

)

trackBy

(

contractStateType

out

criteria

)

trackBy

(

contractStateType

out

paging

)

trackBy

(

contractStateType

out

criteria

paging

)

trackBy

(

contractStateType

out

criteria

sorting

)

trackBy

(

contractStateType

out

criteria

paging

sorting

)

tryLockFungibleStatesForSpending

(

lockId

eligibleStatesQuery

amount

contractStateType

out

)

open fun whenConsumed(ref:

)

queryBy

(

)

queryBy

(

criteria

)

queryBy

(

paging

PageSpecification

)

queryBy

(

criteria

paging

PageSpecification

)

queryBy

(

criteria

sorting

Sort

)

queryBy

(

criteria

paging

sorting

)

trackBy

(

)

trackBy

(

paging

)

trackBy

(

criteria

)

trackBy

(

criteria

paging

)

trackBy

(

criteria

sorting

)

package net.corda.core.node.services.diagnostics

trackBy

(

criteria

paging

sorting

)

Module Contents

@DoNotImplement interface DiagnosticsService

Module Contents

abstract fun nodeVersionInfo():

NodeVersionInfo

data class NodeVersionInfo

Module Contents

NodeVersionInfo(releaseVersion:

revision

platformVersion

vendor

)

package net.corda.core.node.services.vault

Module Contents

enum class AggregateFunctionType

Module Contents

sealed class AttachmentQueryCriteria :

Module Contents

AndVisitor

Module Contents

AndComposition(a:

)

data class AttachmentsQueryCriteria :

Module Contents

filenameCondition

uploadDateCondition

)

)

filenameCondition

)

val contractClassNamesCondition:

filenameCondition

uploadDateCondition

contractClassNamesCondition

signersCondition

isSignedCondition

versionCondition

)

fun copy(uploaderCondition:

filenameCondition

uploadDateCondition

)

val filenameCondition:

fun isSigned(isSignedPredicate:

)

val isSignedCondition:

val signersCondition:

val uploadDateCondition:

val uploaderCondition:

val versionCondition:

fun visit(parser:

)

fun withContractClassNames(contractClassNamesPredicate:

)

fun withFilename(filenamePredicate:

)

fun withSigners(signersPredicate:

)

fun withUploadDate(uploadDatePredicate:

)

fun withUploader(uploaderPredicate:

)

fun withVersion(versionPredicate:

)

OrVisitor

Module Contents

OrComposition(a:

)

)

)

data class AttachmentSort :

Module Contents

AttachmentSort(columns:

enum class AttachmentSortAttribute

)

Module Contents

data class AttachmentSortColumn

Module Contents

AttachmentSortColumn(sortAttribute:

direction

)

val columns:

interface AttachmentsQueryCriteriaParser :

Module Contents

)

interface BaseQueryCriteriaParser<Q :

abstract fun parse(criteria:

Module Contents

sorting

)

abstract fun parseAnd(left:

right

)

abstract fun parseOr(left:

right

)

enum class BinaryComparisonOperator :

abstract class BaseSort

Module Contents

BaseSort()

enum class BinaryLogicalOperator :

Module Contents

GREATER_THAN

GREATER_THAN_OR_EQUAL

LESS_THAN

LESS_THAN_OR_EQUAL

Module Contents

Module Contents

avg

(

groupByColumns

orderBy

)

~~avg~~

(

groupByColumns

orderBy

)

avg

(

groupByColumns

orderBy

)

between

(

from

)

~~between~~

(

from

)

between

(

from

)

between

(

from

)

Between

compare

(

operator

value

)

comparePredicate

(

operator

value

)

~~comparePredicate~~

(

operator

value

)

comparePredicate

(

operator

value

)

count

(

)

~~count~~

(

)

count

(

)

equal

(

value

exactMatch

)

~~equal~~

(

value

exactMatch

)

equal

(

value

exactMatch

)

exactMatch

)

functionPredicate

(

predicate

groupByColumns

orderBy

)

~~functionPredicate~~

(

predicate

groupByColumns

orderBy

)

functionPredicate

(

predicate

groupByColumns

orderBy

)

greaterThan

(

value

)

~~greaterThan~~

(

value

)

greaterThan

(

value

)

greaterThan

(

value

)

greaterThanOrEqual

(

value

)

~~greaterThanOrEqual~~

(

value

)

greaterThanOrEqual

(

value

)

greaterThanOrEqual

(

value

)

(

collection

exactMatch

)

(

collection

exactMatch

)

(

collection

exactMatch

)

(

collection

exactMatch

)

isNull

(

)

~~isNull~~

(

)

isNull

(

)

lessThan

(

value

)

~~lessThan~~

(

value

)

lessThan

(

value

)

lessThan

(

value

)

lessThanOrEqual

(

value

)

~~lessThanOrEqual~~

(

value

)

lessThanOrEqual

(

value

)

lessThanOrEqual

(

value

)

exactMatch

)

(

string

exactMatch

)

~~like~~

(

string

exactMatch

)

(

string

exactMatch

)

max

(

groupByColumns

orderBy

)

~~max~~

(

groupByColumns

orderBy

)

max

(

groupByColumns

orderBy

)

min

(

groupByColumns

orderBy

)

~~min~~

(

groupByColumns

orderBy

)

min

(

groupByColumns

orderBy

)

notEqual

(

value

exactMatch

)

~~notEqual~~

(

value

exactMatch

)

notEqual

(

value

exactMatch

)

fun <R> notEqual(value:

exactMatch

)

notIn

(

collection

exactMatch

)

~~notIn~~

(

collection

exactMatch

)

notIn

(

collection

exactMatch

)

notIn

(

collection

exactMatch

)

exactMatch

)

notLike

(

string

exactMatch

)

~~notLike~~

(

string

exactMatch

)

notLike

(

string

exactMatch

)

notNull

(

)

~~notNull~~

(

)

notNull

(

)

predicate

(

predicate

)

~~predicate~~

(

predicate

)

predicate

(

predicate

)

sum

(

groupByColumns

orderBy

)

~~sum~~

(

groupByColumns

orderBy

)

sum

(

groupByColumns

orderBy

enum class CollectionOperator :

)

Module Contents

class Column<O, out C>

Module Contents

)

)

)

declaringClass

)

sealed class ColumnPredicate<C>

Module Contents

data class AggregateFunction<C> :

Module Contents

AggregateFunction(type:

)

data class Between<C :

Between(rightFromLiteral:

Module Contents

rightToLiteral

)

val rightFromLiteral:

val rightToLiteral:

data class BinaryComparison<C :

BinaryComparison(operator:

Module Contents

rightLiteral

)

data class CollectionExpression<C> :

CollectionExpression(operator:

Module Contents

rightLiteral

)

data class EqualityComparison<C> :

EqualityComparison(operator:

Module Contents

rightLiteral

)

data class NullExpression<C> :

data class Likeness :

Module Contents

rightLiteral

)

Module Contents

NullExpression(operator:

)

@DoNotImplement interface CordaTransactionSupport

Module Contents

abstract fun <T> transaction(statement:

SessionScope

(

)

sealed class CriteriaExpression<O, out T>

Module Contents

data class AggregateFunctionExpression<O, C> :

AggregateFunctionExpression(column:

Module Contents

predicate

groupByColumns

orderBy

)

data class BinaryLogical<O> :

Module Contents

right

operator

)

val right:

data class ColumnPredicateExpression<O, C> :

ColumnPredicateExpression(column:

Module Contents

predicate

)

Module Contents

)

const val DEFAULT_PAGE_NUM:

const val DEFAULT_PAGE_SIZE:

enum class EqualityComparisonOperator :

Module Contents

NOT_EQUAL_IGNORE_CASE

Module Contents

interface GenericQueryCriteria<Q :

interface ChainableQueryCriteria<Q :

Module Contents

Module Contents

interface AndVisitor<Q :

Module Contents

)

interface OrVisitor<Q :

Module Contents

)

abstract infix fun and(criteria:

)

abstract infix fun or(criteria:

)

abstract fun visit(parser:

)

@DoNotImplement interface IQueryCriteriaParser :

Sort

Module Contents

)

)

)

abstract fun <L :

parseCriteria

(

criteria

)

)

enum class LikenessOperator :

Module Contents

const val MAX_PAGE_SIZE:

enum class NullOperator :

@DoNotImplement interface Operator

Module Contents

IS_NULL

NOT_NULL

data class PageSpecification

Module Contents

PageSpecification(pageNumber:

pageSize

)

sealed class QueryCriteria :

Module Contents

abstract class CommonQueryCriteria :

Module Contents

)

open val constraintTypes:

Module Contents

CommonQueryCriteria()

open val constraints:

abstract val contractStateTypes:

out

open val exactParticipants:

open val externalIds:

open val participants:

open val relevancyStatus:

abstract val status:

)

data class FungibleAssetQueryCriteria :

Module Contents

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

exactParticipants

)

out

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

relevancyStatus

)

owner

quantity

issuer

issuerRef

status

contractStateTypes

out

)

)

out

)

)

fun withIssuer(issuer:

)

fun withOwner(owner:

)

)

)

)

)

fun withissuerRef(issuerRef:

)

data class FungibleStateQueryCriteria :

FungibleStateQueryCriteria(participants:

Module Contents

quantity

status

contractStateTypes

out

relevancyStatus

)

out

)

out

)

)

)

)

)

data class LinearStateQueryCriteria :

Module Contents

uuid

externalId

status

contractStateTypes

out

relevancyStatus

)

uuid

externalId

status

contractStateTypes

out

)

linearId

status

contractStateTypes

out

relevancyStatus

)

linearId

status

contractStateTypes

out

)

uuid

externalId

status

contractStateTypes

out

relevancyStatus

exactParticipants

)

out

uuid

externalId

status

contractStateTypes

out

)

uuid

externalId

status

contractStateTypes

out

relevancyStatus

)

)

out

)

)

fun withExternalId(externalId:

)

)

)

)

fun withUuid(uuid:

)

data class SoftLockingCondition

Module Contents

)

Module Contents

SoftLockingCondition(type:

lockIds

)

enum class SoftLockingType

Module Contents

LOCKED_ONLY

SPECIFIED

UNLOCKED_AND_SPECIFIED

UNLOCKED_ONLY

data class TimeCondition

Module Contents

predicate

)

enum class TimeInstantType

Module Contents

data class VaultCustomQueryCriteria<L :

RECORDED

Module Contents

status

contractStateTypes

out

)

status

contractStateTypes

out

relevancyStatus

)

out

status

contractStateTypes

out

)

)

out

)

fun withExpression(expression:

)

)

)

data class VaultQueryCriteria :

Module Contents

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

)

)

contractStateTypes

out

)

contractStateTypes

out

stateRefs

)

contractStateTypes

out

stateRefs

notary

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

exactParticipants

)

out

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

externalIds

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

relevancyStatus

constraintTypes

constraints

participants

)

contractStateTypes

out

stateRefs

notary

softLockingCondition

timeCondition

)

val softLockingCondition:

)

fun withConstraintTypes(constraintTypes:

)

fun withConstraints(constraints:

)

out

)

)

fun withExternalIds(externalIds:

)

fun withNotary(notary:

)

)

)

fun withSoftLockingCondition(softLockingCondition:

SoftLockingCondition

)

fun withStateRefs(stateRefs:

)

)

fun withTimeCondition(timeCondition:

TimeCondition

)

)

)

@DoNotImplement interface SessionScope

Module Contents

abstract val session: <ERROR CLASS>

Module Contents

)

@DoNotImplement interface Attribute

enum class CommonStateAttribute :

Module Contents

Module Contents

enum class FungibleStateAttribute :

Module Contents

enum class LinearStateAttribute :

Module Contents

data class SortColumn

Module Contents

SortColumn(sortAttribute:

direction

)

enum class VaultStateAttribute :

Module Contents

sealed class SortAttribute

Module Contents

data class Custom :

SortAttribute

Module Contents

Custom(entityStateClass:

out

entityStateColumnName

)

val entityStateClass:

out

val entityStateColumnName:

inline fun <A> builder(block:

data class Standard :

Module Contents

)

Builder

(

)

fun <O, C> getColumnName(column:

Column

)

fun getField(fieldName:

entityClass

)

fun <O, C> resolveEnclosingObjectFromColumn(column:

Column

)

fun <O, R> resolveEnclosingObjectFromExpression(expression:

)

package net.corda.core.observable

Module Contents

fun <T> <ERROR CLASS><

continueOnError

(

)

package net.corda.core.schemas

Module Contents

object CommonSchema

object CommonSchemaV1 :

Module Contents

class FungibleState :

FungibleState(participants:

Module Contents

owner

quantity

issuer

issuerRef

)

Module Contents

_participants

)

LinearState(participants:

externalId

uuid

)

interface DirectStatePersistable :

Module Contents

abstract val stateRef:

interface IndirectStatePersistable<T :

abstract val compositeKey:

Module Contents

open class MappedSchema

Module Contents

MappedSchema(schemaFamily:

version

mappedTypes

)

open val migrationResource:

)

object MappedSchemaValidator

Module Contents

class SchemaCrossReferenceReport

Module Contents

SchemaCrossReferenceReport(schema:

entity

referencedSchema

fieldOrMethod

fieldOrMethodType

)

fun crossReferencesToOtherMappedSchema(schema:

)

fun fieldsFromOtherMappedSchema(schema:

)

fun methodsFromOtherMappedSchema(schema:

)

class PersistentState :

PersistentState(stateRef:

Module Contents

)

var stateRef:

data class PersistentStateRef :

PersistentStateRef(stateRef:

Module Contents

interface QueryableState :

)

PersistentStateRef(txId:

index

)

abstract fun generateMappedObject(schema:

Module Contents

)

abstract fun supportedSchemas():

interface StatePersistable

package net.corda.core.serialization

Module Contents

interface CheckpointCustomSerializer<OBJ, PROXY>

Module Contents

)

)

abstract fun hasListed(type:

interface ClassWhitelist

Module Contents

)

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class ConstructorForDeserialization

Module Contents

ConstructorForDeserialization()

enum class ContextPropertyKeys

Module Contents

SERIALIZERS

@Target([AnnotationTarget.CLASS]) @Inherited annotation class CordaSerializable

Module Contents

CordaSerializable()

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefault

Module Contents

CordaSerializationTransformEnumDefault(new:

old

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformEnumDefaults

Module Contents

CordaSerializationTransformEnumDefaults(vararg value:

)

out

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRename

Module Contents

CordaSerializationTransformRename(to:

from

)

@Target([AnnotationTarget.CLASS]) annotation class CordaSerializationTransformRenames

Module Contents

CordaSerializationTransformRenames(vararg value:

)

out

interface CustomSerializationScheme

Module Contents

deserialize

(

bytes

clazz

context

abstract fun getSchemeId():

)

serialize

(

obj

context

)

@Target([AnnotationTarget.CONSTRUCTOR]) annotation class DeprecatedConstructorForDeserialization

Module Contents

DeprecatedConstructorForDeserialization(version:

)

@DoNotImplement interface EncodingWhitelist

Module Contents

abstract fun acceptEncoding(encoding:

)

class MissingAttachmentsException :

Module Contents

)

class MissingAttachmentsRuntimeException :

message

)

Module Contents

message

)

)

data class ObjectWithCompatibleContext<out T :

message

cause

)

ObjectWithCompatibleContext(obj:

Module Contents

context

)

@Target([AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.FUNCTION]) annotation class SerializableCalculatedProperty

Module Contents

SerializableCalculatedProperty()

@DoNotImplement interface SerializationContext

Module Contents

Module Contents

abstract val carpenterDisabled:

abstract val customSerializers:

abstract val encoding:

abstract val encodingWhitelist:

abstract val lenientCarpenterEnabled:

abstract val objectReferencesEnabled:

abstract val preferredSerializationVersion:

abstract val preventDataLoss:

abstract val useCase:

UseCase

abstract fun ~~withAttachmentsClassLoader~~(attachmentHashes:

)

abstract fun withClassLoader(classLoader:

)

abstract fun withCustomSerializers(serializers:

)

abstract fun withEncoding(encoding:

)

abstract fun withEncodingWhitelist(encodingWhitelist:

)

abstract fun withLenientCarpenter():

abstract fun withPreferredSerializationVersion(magic:

)

abstract fun withPreventDataLoss():

abstract fun withProperties(extraProperties:

)

abstract fun withProperty(property:

value

)

abstract fun withWhitelisted(clazz:

)

abstract fun withoutCarpenter():

abstract fun withoutReferences():

interface SerializationCustomSerializer<OBJ, PROXY>

Module Contents

)

)

object SerializationDefaults

Module Contents

val P2P_CONTEXT:

val RPC_CLIENT_CONTEXT:

val RPC_SERVER_CONTEXT:

val SERIALIZATION_FACTORY:

val STORAGE_CONTEXT:

@DoNotImplement interface SerializationEncoding

abstract class SerializationFactory

Module Contents

SerializationFactory()

fun <T> asCurrent(block:

(

)

deserialize

(

byteSequence

clazz

context

)

deserializeWithCompatibleContext

(

byteSequence

clazz

context

ObjectWithCompatibleContext

)

serialize

(

obj

context

)

fun <T> withCurrentContext(context:

typealias SerializationMagic =

block

(

)

@DoNotImplement interface SerializationSchemeContext

Module Contents

interface SerializationToken

Module Contents

abstract fun fromToken(context:

)

interface SerializationWhitelist

Module Contents

interface SerializeAsToken

Module Contents

abstract fun toToken(context:

)

interface SerializeAsTokenContext

Module Contents

abstract fun getSingleton(className:

)

abstract fun putSingleton(toBeTokenized:

)

abstract val serviceHub:

class SerializedBytes<T :

Module Contents

SerializedBytes(bytes:

)

class SingletonSerializationToken :

from

(

obj

serializationFactory

context

)

Module Contents

fun fromToken(context:

)

fun registerWithContext(context:

toBeTokenized

)

singletonSerializationToken

(

toBeTokenized

SingletonSerializationToken

)

abstract class SingletonSerializeAsToken :

SingletonSerializeAsToken()

Module Contents

open fun toToken(context:

)

deserialize

(

serializationFactory

context

)

deserialize

(

serializationFactory

context

)

deserializeWithCompatibleContext

(

serializationFactory

context

ObjectWithCompatibleContext

)

java.sql.Blob

Module Contents

Blob

deserialize

(

serializationFactory

context

)

Module Contents

deserialize

(

serializationFactory

context

)

serialize

(

serializationFactory

context

)

withWhitelist

(

classes

)

package net.corda.core.transactions

Module Contents

@DoNotImplement abstract class BaseTransaction :

Module Contents

BaseTransaction()

filterOutRefs

(

clazz

predicate

)

filterOutRefs

(

crossinline

predicate

(

)

)

filterOutputs

(

clazz

predicate

)

filterOutputs

(

crossinline

predicate

(

)

)

findOutRef

(

clazz

predicate

)

findOutRef

(

crossinline

predicate

(

)

)

findOutput

(

clazz

predicate

)

findOutput

(

crossinline

predicate

(

)

)

)

outRef

(

index

)

outRef

(

state

)

outRefsOfType

(

clazz

)

outRefsOfType

(

)

abstract val outputs:

outputsOfType

(

clazz

)

outputsOfType

(

)

open class ComponentGroup

Module Contents

ComponentGroup(groupIndex:

components

)

class ComponentVisibilityException :

ComponentVisibilityException(id:

Module Contents

reason

)

data class ContractUpgradeFilteredTransaction :

ContractUpgradeFilteredTransaction(visibleComponents:

Module Contents

hiddenComponents

)

ContractUpgradeFilteredTransaction(visibleComponents:

hiddenComponents

digestService

)

class FilteredComponent

Module Contents

FilteredComponent(component:

nonce

)

fun copy(visibleComponents:

hiddenComponents

)

val digestService:

DigestService

val hiddenComponents:

val visibleComponents:

class ContractUpgradeLedgerTransaction :

FilteredComponent

ContractUpgradeLedgerTransaction(inputs:

Module Contents

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

notary

legacyContractAttachment

upgradedContractClassName

upgradedContractAttachment

privacySalt

sigs

networkParameters

)

)

val legacyContractAttachment:

)

val upgradedContractAttachment:

data class ContractUpgradeWireTransaction :

ContractUpgradeWireTransaction(serializedComponents:

Module Contents

privacySalt

ContractUpgradeWireTransaction(serializedComponents:

)

privacySalt

digestService

)

Module Contents

fun buildFilteredTransaction():

privacySalt

ContractUpgradeWireTransaction

)

val legacyContractAttachmentId:

sigs

)

val upgradedContractAttachmentId:

abstract class CoreTransaction :

Module Contents

abstract val networkParametersHash:

data class FilteredComponentGroup :

FilteredComponentGroup(groupIndex:

Module Contents

components

nonces

partialMerkleTree

)

class FilteredTransaction :

fun buildFilteredTransaction(wtx:

Module Contents

filtering

)

fun checkAllComponentsVisible(componentGroupEnum:

ComponentGroupEnum

)

fun checkCommandVisibility(publicKey:

)

fun checkWithFun(checkingFun: (

)

)

val filteredComponentGroups:

class FilteredTransactionVerificationException :

FilteredComponentGroup

FilteredTransactionVerificationException(id:

Module Contents

reason

)

abstract class FullTransaction :

Module Contents

FullTransaction()

protected fun checkNotaryWhitelisted():

class LedgerTransaction :

Module Contents

outputs

commands

attachments

notary

timeWindow

privacySalt

)

data class InOutGroup<out T :

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

out

Module Contents

outputs

groupingKey

)

commandsOfType

(

clazz

)

commandsOfType

(

)

operator fun component10():

CommandWithParties

@CordaInternal fun createForSandbox(inputs:

outputs

commands

attachments

notary

timeWindow

privacySalt

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

)

outputs

commands

attachments

notary

timeWindow

privacySalt

networkParameters

references

digestService

)

)

filterCommands

(

clazz

predicate

)

filterCommands

(

crossinline

predicate

(

)

)

filterInRefs

(

clazz

predicate

)

filterInRefs

(

crossinline

predicate

(

)

)

filterInputs

(

clazz

predicate

)

filterInputs

(

crossinline

predicate

(

)

)

filterReferenceInputRefs

(

clazz

predicate

)

filterReferenceInputRefs

(

crossinline

predicate

(

)

)

filterReferenceInputs

(

clazz

predicate

)

filterReferenceInputs

(

crossinline

predicate

(

)

)

findCommand

(

clazz

predicate

)

findCommand

(

crossinline

predicate

(

)

)

findInRef

(

clazz

predicate

)

findInRef

(

crossinline

predicate

(

)

)

findInput

(

clazz

predicate

)

findInput

(

crossinline

predicate

(

)

)

findReference

(

clazz

predicate

)

findReference

(

crossinline

predicate

(

)

)

findReferenceInputRef

(

clazz

predicate

)

findReferenceInputRef

(

crossinline

predicate

(

)

)

fun getAttachment(index:

)

fun getReferenceInput(index:

fun getAttachment(id:

)

getCommand

(

index

)

)

)

groupStates

(

ofType

selector

(

)

InOutGroup

groupStates

(

noinline

selector

(

)

inRef

(

index

)

inRefsOfType

(

clazz

)

inRefsOfType

(

)

inputsOfType

(

clazz

)

inputsOfType

(

)

referenceInputRefsOfType

(

clazz

)

referenceInputRefsOfType

(

)

referenceInputsOfType

(

clazz

)

@CordaInternal fun specialise(alternateVerifier: (

referenceInputsOfType

(

)

@CordaInternal fun <T> transform(transformer: (

)

Verifier

)

SerializedStateAndRef

SerializedStateAndRef

)

fun verify():

class MissingContractAttachments :

MissingContractAttachments(states:

Module Contents

contractsClassName

minimumRequiredContractClassVersion

Version

)

data class NetworkParametersHash

Module Contents

NetworkParametersHash(hash:

)

class NotaryChangeLedgerTransaction :

NotaryChangeLedgerTransaction(inputs:

Module Contents

notary

newNotary

sigs

)

notary

newNotary

sigs

)

)

)

data class NotaryChangeWireTransaction :

Module Contents

NotaryChangeWireTransaction(inputs:

)

notary

newNotary

)

digestService

)

Module Contents

)

sigs

)

sigs

)

data class ReferenceStateRef

Module Contents

ReferenceStateRef(stateRef:

)

val stateRef:

data class SignedTransaction :

Module Contents

SignedTransaction(ctx:

sigs

SignedTransaction(txBits:

)

sigs

)

class SignaturesMissingException :

SignatureException

SignaturesMissingException(missing:

Module Contents

descriptions

)

)

)

fun ~~isNotaryChangeTransaction~~():

val ~~notaryChangeTx~~:

operator fun plus(sig:

)

operator fun plus(sigList:

)

fun resolveBaseTransaction(servicesForResolution:

)

fun resolveContractUpgradeTransaction(services:

)

)

)

fun resolveTransactionWithSignatures(services:

)

checkSufficientSignatures

)

checkSufficientSignatures

)

@VisibleForTesting fun withAdditionalSignature(keyPair:

signatureMetadata

)

fun withAdditionalSignature(sig:

)

fun withAdditionalSignatures(sigList:

)

open class TransactionBuilder

Module Contents

lockId

inputs

attachments

outputs

commands

window

privacySalt

)

)

fun addAttachment(attachmentId:

lockId

inputs

attachments

outputs

commands

window

privacySalt

references

serviceHub

)

)

)

vararg

keys

)

keys

)

open fun addInputState(stateAndRef:

)

)

contract

notary

encumbrance

constraint

)

contract

constraint

)

constraint

)

open fun addReferenceState(referencedStateAndRef:

)

fun attachments():

protected val attachments:

protected val commands:

protected val inputs:

protected val outputs:

protected var privacySalt:

fun referenceStates():

protected val references:

protected val serviceHub:

fun setPrivacySalt(privacySalt:

fun setTimeWindow(timeWindow:

)

)

fun setTimeWindow(time:

timeTolerance

)

)

fun toSignedTransaction(keyManagementService:

publicKey

signatureMetadata

services

)

)

schemeId

)

schemeId

properties

)

)

protected var window:

fun withItems(vararg items:

@DoNotImplement interface TransactionWithSignatures :

)

open fun checkSignaturesAreValid():

Module Contents

abstract fun getKeyDescriptions(keys:

)

open fun getMissingSigners():

abstract val requiredSigningKeys:

open fun verifyRequiredSignatures(): <ERROR CLASS>

open fun verifySignaturesExcept(vararg allowedToBeMissing:

)

open fun verifySignaturesExcept(allowedToBeMissing:

)

abstract class TraversableTransaction :

Module Contents

)

val availableComponentGroups:

digestService

)

open val componentGroups:

open val networkParametersHash:

class WireTransaction :

Module Contents

)

privacySalt

)

WireTransaction(inputs:

attachments

outputs

commands

notary

timeWindow

privacySalt

)

privacySalt

digestService

)

)

fun checkSignature(sig:

)

@CordaInternal fun ~~createComponentGroups~~(inputs:

outputs

commands

attachments

notary

timeWindow

)

)

@CordaInternal fun resolveStateRefBinaryComponent(stateRef:

services

)

)

fun ~~toLedgerTransaction~~(resolveIdentity: (

)

resolveAttachment

(

)

resolveStateRef

(

)

package net.corda.core.utilities

resolveContractAttachment

(

)

)

Module Contents

sealed class ByteSequence :

Module Contents

open fun compareTo(other:

)

open class Id<out VALUE :

)

offset

size

)

)

end

)

fun subSequence(offset:

size

)

)

)

Module Contents

entityType

timestamp

)

)

newInstance

(

value

entityType

timestamp

)

const val MAX_HASH_HEX_SIZE:

data class NetworkHostAndPort

Module Contents

NetworkHostAndPort(host:

port

)

)

class NonEmptySet<T> :

Module Contents

fun <T> copyOf(elements:

)

)

)

)

second

vararg

rest

)

class OpaqueBytesSubSequence :

fun parallelStream():

open class OpaqueBytes :

Module Contents

)

)

OpaqueBytesSubSequence(bytes:

Module Contents

offset

size

)

class ProgressTracker

Module Contents

ProgressTracker(vararg inputSteps:

open val changes: <ERROR CLASS><

)

sealed class Change

Module Contents

data class Position :

Module Contents

newStep

)

data class Rendering :

Module Contents

ofStep

)

data class Structural :

Module Contents

parent

)

Module Contents

)

Module Contents

)

Module Contents

)

open fun childProgressTracker():

)

val changes: <ERROR CLASS><

open val extraAuditData:

Module Contents

)

var currentStep:

val currentStepRecursive:

fun endWithError(error:

)

fun getChildProgressTracker(step:

)

fun setChildProgressTracker(step:

childProgressTracker

)

val steps: <ERROR CLASS>

val stepsTreeChanges: <ERROR CLASS><

val stepsTreeIndexChanges: <ERROR CLASS><

val topLevelTracker:

interface PropertyDelegate<out T>

Module Contents

abstract operator fun getValue(thisRef:

property

)

Module Contents

sealed class Try<out A>

Module Contents

data class Failure<out A> :

Module Contents

)

data class Success<out A> :

Module Contents

)

inline fun <B, C> combine(other:

function

(

)

fun doOnFailure(action:

)

fun doOnSuccess(action:

)

inline fun flatMap(function: (

)

)

abstract fun getOrThrow():

abstract val isFailure:

abstract val isSuccess:

inline fun map(function: (

)

inline fun <T> on(body: () ->

)

fun throwError():

class UntrustworthyData<out T>

Module Contents

UntrustworthyData(fromUntrustedWorld:

)

@FunctionalInterface interface Validator<in T, out R> :

abstract fun validate(data:

Module Contents

)

fun <R> unwrap(validator:

)

Module Contents

interface VariablePropertyDelegate<T> :

PropertyDelegate

Module Contents

abstract operator fun setValue(thisRef:

property

KProperty

value

)

inline fun <ERROR CLASS>.debug(msg: () ->

)

fun detailedLogger(): <ERROR CLASS>

java.lang.management.ThreadInfo

Module Contents

ThreadInfo

asString

(

maxFrames

)

Module Contents

toBase58String

(

)

toSHA256Bytes

(

)

Module Contents

fun <V>

getOrThrow

(

timeout

)

Module Contents

contextLogger

(

)

Module Contents

sequence

(

offset

size

)

toBase58

(

)

toBase64

(

)

toHex

(

)

toHexString

(

)

Module Contents

days

exactAdd

(

)

hours

millis

minutes

seconds

Module Contents

exactAdd

(

)

Module Contents

base58ToByteArray

(

)

base58ToRealString

(

)

base58toBase64

(

)

base58toHex

(

)

base64ToByteArray

(

)

base64ToRealString

(

)

base64toBase58

(

)

base64toHex

(

)

hexToBase58

(

)

hexToBase64

(

)

hexToByteArray

(

)

hexToRealString

(

)

parseAsHex

(

)

Module Contents

fun <T>

toNonEmptySet

(

)

fun parsePublicKeyBase58(base58String:

loggerFor

(

)

)

fun threadDumpAsString():

inline fun <ERROR CLASS>.trace(msg: () ->

)

fun <T> transient(initializer: () ->

)

PropertyDelegate

inline fun <T, R>

package net.corda.finance

unwrap

(

validator

(

)

Module Contents

AMOUNT

(

amount

token

)

AMOUNT

(

amount

token

)

AMOUNT

(

amount

token

)

)

)

)

)

)

)

fun SWISS_FRANCS(amount:

)

fun SWISS_FRANCS(amount:

)

package net.corda.finance.contracts

fun SWISS_FRANCS(amount:

)

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

issued by

(

deposit

)

issuedBy

(

deposit

)

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

DOLLARS

POUNDS

SWISS_FRANCS

Module Contents

enum class AccrualAdjustment

Module Contents

Adjusted

Unadjusted

interface BilateralNettableState<N :

abstract val bilateralNetState:

Module Contents

open class BusinessCalendar

abstract fun net(other:

)

Module Contents

BusinessCalendar(holidayDates:

)

open fun applyRollConvention(testDate:

dateRollConvention

DateRollConvention

)

fun calculateDaysBetween(startDate:

endDate

dcbYear

dcbDay

)

fun createGenericSchedule(startDate:

period

calendar

dateRollConvention

noOfAdditionalPeriods

endDate

periodOffset

)

)

fun getOffsetDate(startDate:

period

steps

)

open fun isWorkingDay(date:

)

fun moveBusinessDays(date:

direction

)

fun parseDateFromString(it:

)

)

const val CP_PROGRAM_ID:

class CommercialPaper :

Module Contents

CommercialPaper()

const val CP_PROGRAM_ID:

Module Contents

Module Contents

Module Contents

Module Contents

Module Contents

owner

faceValue

maturityDate

)

)

fun withFaceValue(newFaceValue:

Issued

fun withMaturityDate(newMaturityDate:

)

)

)

fun withOwner(newOwner:

)

)

data class Commodity :

TokenizableAssetInfo

Module Contents

Commodity(commodityCode:

displayName

defaultFractionDigits

)

val commodityCode:

val defaultFractionDigits:

val displayName:

fun getInstance(commodityCode:

enum class DateRollConvention

)

Commodity

Module Contents

enum class DateRollDirection

Module Contents

enum class DayCountBasisDay

Module Contents

enum class DayCountBasisYear

Module Contents

interface DealState :

abstract fun generateAgreement(notary:

Module Contents

)

interface FixableDealState :

data class Expression

Module Contents

)

Module Contents

value

)

Module Contents

forDay

ofTenor

)

abstract fun generateFix(ptx:

Module Contents

oldState

fix

)

abstract fun nextFixingOf():

Module Contents

val annualCompoundCount:

(

)

interface MultilateralNettableState<out T :

abstract val multilateralNetState:

Module Contents

interface NetCommand :

Module Contents

Module Contents

interface NettableState<N :

out

MultilateralNettableState

enum class PaymentRule

Module Contents

Module Contents

)

Module Contents

fun daysToMaturity(startDate:

calendar

)

package net.corda.finance.contracts.asset

Module Contents

data class BilateralNetState<P :

BilateralNetState(partyKeys:

Module Contents

template

)

CASH

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

val exitKeys: <ERROR CLASS>

Module Contents

amount

owner

)

owner

)

)

infix fun issuedBy(party:

)

infix fun issuedBy(deposit:

)

infix fun ownedBy(owner:

)

infix fun withDeposit(deposit:

)

)

fun extractCommands(commands:

newOwner

)

fun deriveState(txState:

amount

owner

)

)

fun generateExitCommand(amount:

)

tokenDef

pennies

owner

notary

)

fun generateMoveCommand():

amount

owner

notary

)

)

data class MultilateralNetState<P :

MultilateralNetState(template:

Module Contents

)

val template:

interface NetState<P :

data class SetLifecycle :

Module Contents

abstract val template:

Module Contents

Module Contents

Module Contents

)

Module Contents

Module Contents

out

)

out

Module Contents

)

Module Contents

SetLifecycle(lifecycle:

)

data class Settle<P :

Module Contents

)

Module Contents

val multilateralNetState:

Module Contents

obligor

template

quantity

beneficiary

)

val bilateralNetState:

)

)

Terms(acceptableContracts:

newOwner

)

Module Contents

acceptableIssuedProducts

dueBefore

timeTolerance

)

val acceptableContracts:

val acceptableIssuedProducts:

)

abstract class OnLedgerAsset<T :

out

Module Contents

abstract fun deriveState(txState:

amount

owner

)

abstract fun extractCommands(commands:

)

fun ~~generateExit~~(tx:

amountIssued

assetStates

)

amountIssued

assetStates

payChangeTo

)

~~generateExit~~

(

amountIssued

assetStates

deriveState

(

)

generateMoveCommand

(

)

generateExitCommand

(

)

)

generateExit

(

amountIssued

assetStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

abstract fun generateExitCommand(amount:

generateExitCommand

(

)

)

)

generateIssue

(

transactionState

issueCommand

)

abstract fun generateMoveCommand():

generateSpend

(

amount

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

generateSpend

(

payments

acceptableStates

payChangeTo

deriveState

(

)

generateMoveCommand

(

)

)

data class PartyAndAmount<T :

package net.corda.finance.contracts.utils

Module Contents

PartyAndAmount(party:

amount

)

STATE

(

dueBefore

)

between

(

parties

)

extractAmountsDue

(

product

states

)

issued by

(

party

)

issuedBy

(

party

)

netAmountsDue

(

balances

)

owned by

(

owner

)

ownedBy

(

owner

)

sumAmountsDue

(

balances

)

Module Contents

Module Contents

package net.corda.finance.flows

sumCash

(

)

sumCashBy

(

owner

)

sumCashOrNull

(

)

sumCashOrZero

(

currency

)

sumFungibleOrNull

(

)

sumFungibleOrZero

(

token

)

sumObligations

(

)

sumObligationsOrNull

(

)

sumObligationsOrZero

(

issuanceDef

)

Module Contents

abstract class AbstractCashFlow<out T> :

AbstractCashFlow(progressTracker:

Module Contents

abstract class AbstractRequest

)

Module Contents

AbstractRequest(amount:

)

object FINALISING_TX :

protected fun finaliseTx(tx:

object GENERATING_TX :

Module Contents

recipient

)

sessions

message

)

class CashException :

Module Contents

CashException(message:

cause

@InitiatingFlow @StartableByRPC class CashExitFlow :

)

Module Contents

issuerRef

)

CashExitFlow(request:

)

issuerRef

progressTracker

)

Module Contents

issuerRef

)

@InitiatedBy(CashExitFlow) class CashExitResponderFlow :

CashExitResponderFlow(otherSide:

Module Contents

)

@StartableByRPC class CashIssueAndPaymentFlow :

Module Contents

CashIssueAndPaymentFlow(request:

issueRef

recipient

anonymous

notary

)

IssueAndPaymentRequest

)

class IssueAndPaymentRequest :

issueRef

recipient

anonymous

notary

progressTracker

)

IssueAndPaymentRequest(amount:

Module Contents

issueRef

recipient

notary

anonymous

)

val PAYING_RECIPIENT:

@StartableByRPC class CashIssueFlow :

Module Contents

issuerBankPartyRef

notary

)

CashIssueFlow(request:

IssueRequest

)

@StartableByRPC @InitiatingFlow open class CashPaymentFlow :

issuerBankPartyRef

notary

progressTracker

)

Module Contents

issueRef

notary

)

Module Contents

recipient

)

recipient

anonymous

)

recipient

anonymous

notary

)

CashPaymentFlow(request:

PaymentRequest

)

recipient

anonymous

progressTracker

issuerConstraint

notary

)

class PaymentRequest :

Module Contents

PaymentRequest(amount:

recipient

anonymous

issuerConstraint

notary

)

@InitiatedBy(CashPaymentFlow) class CashPaymentReceiverFlow :

CashPaymentReceiverFlow(otherSide:

Module Contents

)

object TwoPartyDealFlow

Module Contents

class Acceptor :

Secondary

Acceptor(otherSideSession:

Module Contents

progressTracker

protected open fun assembleSharedTX(handshake:

)

)

protected open fun validateHandshake(handshake:

)

Module Contents

dealBeingOffered

)

val dealBeingOffered:

data class Handshake<out T>

Module Contents

primaryIdentity

secondaryIdentity

)

val secondaryIdentity:

Instigator(otherSideSession:

class Instigator :

Primary

Module Contents

payload

progressTracker

open fun checkProposal(stx:

)

)

open val notaryParty:

open val payload:

abstract class Primary :

Module Contents

Primary(progressTracker:

)

object SENDING_PROPOSAL :

abstract fun checkProposal(stx:

)

abstract val notaryParty:

abstract val payload:

abstract class Secondary :

Secondary(progressTracker:

Module Contents

)

protected abstract fun assembleSharedTX(handshake:

)

protected abstract fun validateHandshake(handshake:

)

class AssetMismatchException :

object TwoPartyTradeFlow

Module Contents

AssetMismatchException(expectedTypeName:

Module Contents

typeName

)

val expectedTypeName:

Module Contents

Buyer(otherSideSession:

notary

acceptablePrice

typeToBuy

out

)

notary

acceptablePrice

typeToBuy

out

anonymous

)

Module Contents

Module Contents

cashSigningPubKeys

)

val cashSigningPubKeys:

object AWAITING_PROPOSAL :

Module Contents

Seller(otherSideSession:

assetToSell

price

myParty

progressTracker

)

object VERIFYING_AND_SIGNING :

Module Contents

data class SellerTradeInfo

Module Contents

SellerTradeInfo(price:

payToIdentity

)

class UnacceptablePriceException :

UnacceptablePriceException(givenPrice:

Module Contents

package net.corda.finance.schemas

)

Module Contents

object CashSchema

object CashSchemaV1 :

Module Contents

PersistentCashState(owner:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object CommercialPaperSchema

object CommercialPaperSchemaV1 :

class PersistentCommercialPaperState :

Module Contents

PersistentCommercialPaperState(issuancePartyHash:

Module Contents

issuanceRef

ownerHash

maturity

faceValue

currency

faceValueIssuerPartyHash

faceValueIssuerRef

)

var faceValueIssuerPartyHash:

var faceValueIssuerRef:

var issuancePartyHash:

package net.corda.finance.test

Module Contents

object CashSchema

object SampleCashSchemaV1 :

Module Contents

PersistentCashState(ownerHash:

Module Contents

pennies

currency

issuerPartyHash

issuerRef

)

object SampleCashSchemaV2 :

Module Contents

PersistentCashState(currency:

FungibleState

Module Contents

participants

owner

quantity

issuerParty

issuerRef

)

object SampleCashSchemaV3 :

Module Contents

PersistentCashState(participants:

Module Contents

owner

pennies

currency

issuer

issuerRef

)

package net.corda.finance.workflows

Module Contents

object CommercialPaperUtils

Module Contents

fun generateIssue(issuance:

faceValue

maturityDate

notary

)

paper

newOwner

)

fun generateRedeem(tx:

paper

services

ourIdentity

)

getCashBalance

(

currency

)

getCashBalance

(

currency

)

getCashBalances

(

)

getCashBalances

(

)

package net.corda.finance.workflows.asset

Module Contents

object CashUtils

Module Contents

amount

onlyFromParties

)

amount

ourIdentity

onlyFromParties

anonymous

)

payments

onlyFromParties

)

fun generateCashIssue(tx:

payments

ourIdentity

onlyFromParties

anonymous

)

object ObligationUtils

Module Contents

obligor

acceptableContract

amount

dueBefore

beneficiary

notary

)

generateCloseOutNetting

(

signer

package net.corda.finance.workflows.asset.selection

vararg

inputs

)

generateExit

(

amountIssued

assetStates

)

generateIssue

(

obligor

issuanceDef

pennies

beneficiary

notary

)

generatePaymentNetting

(

issued

notary

vararg

inputs

)

generateSetLifecycle

(

statesAndRefs

lifecycle

notary

)

generateSettle

(

statesAndRefs

assetStatesAndRefs

moveCommand

notary

)

Module Contents

abstract class AbstractCashSelection

Module Contents

AbstractCashSelection(maxRetries:

retrySleep

retryCap

protected abstract fun executeQuery(connection:

)

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

fun getInstance(metadata: () ->

)

val instance:

AtomicReference

protected abstract fun isCompatible(metadata:

)

abstract fun toString():

fun unconsumedCashStatesForSpending(services:

amount

class CashSelectionH2Impl :

onlyFromIssuerParties

notary

lockId

withIssuerRefs

)

Module Contents

CashSelectionH2Impl()

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

class CashSelectionPostgreSQLImpl :

)

CashSelectionPostgreSQLImpl()

Module Contents

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

class CashSelectionSQLServerImpl :

)

CashSelectionSQLServerImpl()

Module Contents

val JDBC_DRIVER_NAME_REGEX: <ERROR CLASS>

amount

lockId

notary

onlyFromIssuerParties

withIssuerRefs

withResultSet

(

)

)

package net.corda.finance.workflows.utils

)

Module Contents

val TEST_CALENDAR_NAMES: <ERROR CLASS>

class UnknownCalendar :

Module Contents

UnknownCalendar(name:

fun loadTestCalendar(name:

)

package net.corda.testing.driver

)

BusinessCalendar

Module Contents

@DoNotImplement interface DriverDSL

Module Contents

abstract fun baseDirectory(nodeName:

)

open val defaultNotaryHandle:

open val defaultNotaryIdentity:

open val defaultNotaryNode:

abstract val notaryHandles:

open fun startNode():

abstract fun startNode(parameters:

)

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

logLevelOverride

)

open fun startWebserver(handle:

providedName

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

)

abstract fun startWebserver(handle:

WebserverHandle

maximumHeapSize

)

data class DriverParameters

Module Contents

DriverParameters(cordappsForAllNodes:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

inMemoryDB

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

premigrateH2Database

val allowHibernateToManageAppSchema:

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

)

driverDirectory

portAllocation

debugPortAllocation

systemProperties

useTestClock

startNodesInProcess

waitForAllNodesToFinish

notarySpecs

extraCordappPackagesToScan

jmxPolicy

networkParameters

notaryCustomOverrides

inMemoryDB

cordappsForAllNodes

djvmBootstrapSource

djvmCordaSource

environmentVariables

allowHibernateToManageAppSchema

)

val debugPortAllocation:

val environmentVariables:

val djvmBootstrapSource:

val ~~extraCordappPackagesToScan~~:

val notaryCustomOverrides:

val premigrateH2Database:

val startNodesInProcess:

val waitForAllNodesToFinish:

val systemProperties:

fun withAllowHibernateToManageAppSchema(value:

)

)

fun withDebugPortAllocation(debugPortAllocation:

)

fun withDjvmBootstrapSource(djvmBootstrapSource:

)

fun withDjvmCordaSource(djvmCordaSource:

)

fun withDriverDirectory(driverDirectory:

)

fun withEnvironmentVariables(variables:

)

fun ~~withExtraCordappPackagesToScan~~(extraCordappPackagesToScan:

)

fun withInMemoryDB(inMemoryDB:

)

fun withIsDebug(isDebug:

)

fun withJmxPolicy(jmxPolicy:

)

)

fun withNotaryCustomOverrides(notaryCustomOverrides:

)

)

fun withPortAllocation(portAllocation:

)

fun withStartNodesInProcess(startNodesInProcess:

)

fun withSystemProperties(systemProperties:

)

fun withUseTestClock(useTestClock:

)

fun withWaitForAllNodesToFinish(waitForAllNodesToFinish:

)

@DoNotImplement interface InProcess :

Module Contents

registerInitiatedFlow

(

initiatedFlowClass

)

open fun <T> startFlow(logic:

)

Module Contents

JmxPolicy(jmxHttpServerPortAllocation:

JmxPolicy(startJmxHttpServer:

)

jmxHttpServerPortAllocation

)

fun defaultEnabled():

val jmxHttpServerPortAllocation:

val startJmxHttpServer:

@DoNotImplement interface NodeHandle :

abstract val baseDirectory:

Module Contents

abstract val jmxAddress:

abstract val nodeInfo:

abstract val p2pAddress:

abstract val rpc:

abstract val rpcAddress:

abstract val rpcAdminAddress:

data class NodeParameters

abstract val rpcUsers:

Module Contents

NodeParameters()

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

logLevelOverride

rpcAddress

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

)

rpcUsers

verifierType

customOverrides

startInSameProcess

maximumHeapSize

additionalCordapps

flowOverrides

out

out

out

)

out

out

out

val logLevelOverride:

val startInSameProcess:

val verifierType:

)

fun withCustomOverrides(customOverrides:

)

fun withFlowOverrides(flowOverrides:

out

out

)

fun withLogLevelOverride(logLevelOverride:

)

fun withMaximumHeapSize(maximumHeapSize:

)

fun withProvidedName(providedName:

)

fun withRpcUsers(rpcUsers:

User

)

fun withStartInSameProcess(startInSameProcess:

)

fun withVerifierType(verifierType:

)

@DoNotImplement interface OutOfProcess :

data class NotaryHandle

Module Contents

NotaryHandle(identity:

validating

nodeHandles

)

@DoNotImplement abstract class PortAllocation

Module Contents

abstract val process:

Process

Module Contents

PortAllocation()

const val DEFAULT_START_PORT:

const val FIRST_EPHEMERAL_PORT:

@DoNotImplement open class ~~Incremental~~ :

Incremental(startingPort:

Module Contents

)

open fun ~~nextPort~~():

val ~~portCounter~~:

AtomicInteger

val defaultAllocator:

fun nextHostAndPort():

abstract fun nextPort():

WebserverHandle(listenAddress:

enum class VerifierType

Module Contents

InMemory

data class ~~WebserverHandle~~

Module Contents

process

)

fun <A> driver(defaultParameters:

dsl

DriverDSL

(

)

package net.corda.testing.dsl

logFile

(

)

File

Module Contents

AttachmentResolutionException(attachmentId:

Module Contents

class DoubleSpentInputs :

)

Module Contents

DoubleSpentInputs(ids:

class DuplicateOutputLabel :

)

DuplicateOutputLabel(label:

Module Contents

@DoNotImplement sealed class EnforceVerifyOrFail

)

class LedgerDSL<out T :

out

Module Contents

LedgerDSL(interpreter:

notary

)

val interpreter:

output

(

)

outputStateAndRef

(

)

fun <S :

retrieveOutput

(

clazz

label

)

fun transaction(label:

transactionBuilder

dsl

(

)

)

(

)

)

fun unverifiedTransaction(label:

transactionBuilder

dsl

(

)

)

@DoNotImplement interface LedgerDSLInterpreter<out T :

abstract fun _transaction(transactionLabel:

Module Contents

transactionBuilder

dsl

(

)

)

(

)

)

abstract fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

abstract fun attachment(attachment:

)

@DoNotImplement interface OutputStateLookup

Module Contents

abstract fun <S :

retrieveOutputStateAndRef

(

clazz

label

)

data class TestLedgerDSLInterpreter :

TestLedgerDSLInterpreter(services:

Module Contents

)

class TypeMismatch :

Module Contents

TypeMismatch(requested:

actual

)

class VerifiesFailed :

VerifiesFailed(transactionName:

Module Contents

cause

fun _transaction(transactionLabel:

)

transactionBuilder

dsl

(

)

)

(

)

)

fun _unverifiedTransaction(transactionLabel:

transactionBuilder

dsl

(

)

)

fun attachment(attachment:

)

fun transactionName(transactionHash:

fun outputToLabel(state:

)

retrieveOutputStateAndRef

(

clazz

label

)

)

val transactionsToVerify:

val transactionsUnverified:

val wireTransactions:

data class TestTransactionDSLInterpreter :

TestTransactionDSLInterpreter(ledgerInterpreter:

Module Contents

transactionBuilder

)

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

fun attachment(attachmentId:

)

commandData

)

)

val ledgerInterpreter:

label

notary

encumbrance

attachmentConstraint

contractState

)

fun reference(stateRef:

)

val services:

fun timeWindow(data:

)

val transactionBuilder:

fun verifies():

class TransactionDSL<out T :

TransactionDSL(interpreter:

Module Contents

notary

)

)

attachmentId

signers

jarManifestAttributes

)

attachmentId

)

fun attachments(vararg contractClassNames:

)

commandData

)

fun input(stateLabel:

)

stateLabel

)

state

)

label

notary

contractState

)

label

encumbrance

contractState

)

label

contractState

)

notary

contractState

)

encumbrance

contractState

)

contractState

)

fun reference(stateLabel:

fun reference(contractClassName:

)

state

)

tolerance

)

(

)

)

@DoNotImplement interface TransactionDSLInterpreter :

Module Contents

)

attachmentId

signers

)

attachmentId

signers

jarManifestAttributes

)

(

)

)

abstract fun attachment(attachmentId:

)

abstract fun command(signers:

commandData

)

abstract fun input(stateRef:

)

abstract val ledgerInterpreter:

abstract fun output(contractClassName:

label

notary

encumbrance

attachmentConstraint

contractState

)

abstract fun reference(stateRef:

)

abstract fun timeWindow(data:

)

@DoNotImplement interface Verifies

Module Contents

open fun fails():

open infix fun fails with(msg:

)

open fun failsWith(expectedMessage:

)

abstract fun verifies():

package net.corda.testing.flows

Module Contents

infix fun <T :

out

from

(

session

)

kotlin.collections.Map

Module Contents

from

(

session

)

kotlin.reflect.KClass

Module Contents

infix fun <T :

from

(

session

)

receiveAll

(

session

out

vararg

sessions

out

)

receiveAll

(

receiveType

session

vararg

sessions

)

receiveAll

(

session

vararg

sessions

)

inline fun <reified P :

TestStartedNode

registerCordappFlowFactory

(

initiatingFlowClass

out

initiatedFlowVersion

noinline

flowFactory

(

)

TestStartedNode

registerCoreFlowFactory

(

initiatingFlowClass

out

initiatedFlowClass

flowFactory

(

)

track

package net.corda.testing.http

)

Module Contents

class HttpApi

Module Contents

HttpApi(root:

fun fromHostAndPort(hostAndPort:

mapper

)

base

protocol

mapper

)

HttpApi

getJson

(

path

params

val mapper: <ERROR CLASS>

)

data

)

data

)

data

)

Module Contents

val defaultMapper: <ERROR CLASS>

getJson

(

url

params

package net.corda.testing.node

mapper

)

data

)

data

)

data

)

Module Contents

@DoNotImplement abstract class ClusterSpec

Module Contents

Module Contents

)

abstract val clusterSize:

fun copyDatabaseSnapshot(baseDirectory:

object DatabaseSnapshot

Module Contents

)

fun databaseFilename(baseDirectory:

)

class InMemoryMessagingNetwork :

data class DistributedServiceHandle :

Module Contents

MessageRecipientGroup

Module Contents

DistributedServiceHandle(party:

)

interface LatencyCalculator

Module Contents

abstract fun between(sender:

receiver

)

class MockMessagingService

class MessageTransfer

Module Contents

Module Contents

)

data class PeerHandle :

@DoNotImplement sealed class ServicePeerAllocationStrategy

Module Contents

name

)

)

Module Contents

class Random :

Module Contents

Random(random:

SplittableRandom

)

pickFrom

)

Module Contents

RoundRobin()

pickFrom

abstract fun <A> pickNext(service:

)

pickFrom

val receivedMessages: <ERROR CLASS><

)

val endpointsExternal:

)

val sentMessages: <ERROR CLASS><

fun stop():

MockNetFlowTimeOut(timeout:

class MockNetFlowTimeOut

Module Contents

maxRestartCount

backoffBase

)

class MockNetNotaryConfig

Module Contents

MockNetNotaryConfig(validating:

val extraConfig: <ERROR CLASS>?

extraConfig

className

serviceLegalName

)

val serviceLegalName:

val validating:

open class MockNetwork

Module Contents

parameters

)

MockNetwork(parameters:

)

defaultParameters

networkSendManuallyPumped

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

fun baseDirectory(nodeId:

)

)

val ~~cordappPackages~~:

fun createNode(parameters:

)

fun createNode(legalName:

forcedID

entropyRoot

configOverrides

)

fun createPartyNode(legalName:

)

fun createUnstartedNode(parameters:

)

fun createUnstartedNode(legalName:

forcedID

entropyRoot

configOverrides

)

val defaultNotaryIdentity:

val defaultNotaryNode:

val defaultParameters:

fun runNetwork(rounds:

)

data class MockNetworkNotarySpec

Module Contents

validating

className

)

data class MockNetworkParameters

validating

)

Module Contents

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

MockNetworkParameters(cordappsForAllNodes:

)

)

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

cordappsForAllNodes

fun copy(networkSendManuallyPumped:

)

threadPerNode

servicePeerAllocationStrategy

notarySpecs

networkParameters

)

val notarySpecs:

val threadPerNode:

)

)

fun withNetworkSendManuallyPumped(networkSendManuallyPumped:

)

)

fun withServicePeerAllocationStrategy(servicePeerAllocationStrategy:

)

fun withThreadPerNode(threadPerNode:

)

class MockNodeConfigOverrides

Module Contents

MockNodeConfigOverrides(extraDataSourceProperties:

notary

flowTimeout

)

val extraDataSourceProperties:

data class MockNodeParameters

Module Contents

legalName

entropyRoot

configOverrides

)

legalName

entropyRoot

configOverrides

additionalCordapps

)

val configOverrides:

legalName

entropyRoot

configOverrides

)

)

fun withConfigOverrides(configOverrides:

)

fun withEntropyRoot(entropyRoot:

)

fun withForcedID(forcedID:

)

fun withLegalName(legalName:

)

open class MockServices :

Module Contents

initialIdentity

identityService

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

)

initialIdentity

identityService

networkParameters

vararg

moreKeys

keyManagementService

)

initialIdentityName

identityService

key

vararg

moreKeys

)

initialIdentityName

identityService

)

)

identityService

key

vararg

moreKeys

)

identityService

)

initialIdentityName

identityService

networkParameters

)

MockServices(firstIdentity: <ERROR CLASS>, vararg moreIdentities: <ERROR CLASS>)

initialIdentityName

identityService

networkParameters

key

)

MockServices(firstIdentity: <ERROR CLASS>, networkParameters:

vararg

moreIdentities

)

firstIdentity

vararg

moreIdentities

)

firstIdentity

networkParameters

fun addMockCordapp(contractClassName:

vararg

moreIdentities

)

MockServices()

)

open val contractUpgradeService:

val attachments:

MockAttachmentStorage

open val clock:

TestClock

cordaService

(

type

)

val cordappClassloader:

open val cordappProvider:

open val diagnosticsService:

open val identityService:

open fun jdbcSession():

open val keyManagementService:

open fun loadContractAttachment(stateRef:

open fun loadState(stateRef:

)

)

open fun loadStates(stateRefs:

)

fun makeTestDataSourceProperties(nodeName:

fun makeTestDatabaseAndMockServices(cordappPackages:

)

Properties

identityService

initialIdentity

networkParameters

vararg

moreKeys

)

fun makeTestDatabaseAndPersistentServices(cordappPackages:

initialIdentity

networkParameters

moreKeys

moreIdentities

cacheFactory

TestingNamedCacheFactory

)

open val myInfo:

open val networkMapCache:

open val networkParameters:

open var networkParametersService:

open fun recordTransactions(statesToRecord:

txs

)

open fun registerUnloadHandler(runOnStop: () ->

protected val servicesForResolution:

)

Nothing

open val validatedTransactions:

open val vaultService:

open fun <T> withEntityManager(block: <ERROR CLASS>.() ->

)

open fun withEntityManager(block:

)

data class NotarySpec

Module Contents

validating

rpcUsers

verifierType

cluster

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

)

validating

rpcUsers

verifierType

cluster

maximumHeapSize

startInProcess

)

validating

rpcUsers

verifierType

cluster

startInProcess

)

validating

rpcUsers

verifierType

cluster

)

class StartedMockNode

Module Contents

findStateMachines

(

flowClass

)

)

registerInitiatedFlow

(

initiatedFlowClass

)

registerInitiatedFlow

(

initiatingFlowClass

out

initiatedFlowClass

)

fun <T> startFlow(logic:

)

fun stop(): <ERROR CLASS>

fun <T> transaction(statement: () ->

)

class TestClock

Module Contents

TestClock(delegateClock:

)

fun advanceBy(duration:

)

fun setTo(newInstant:

)

@DoNotImplement abstract class TestCordapp

Module Contents

fun findCordapp(scanPackage:

)

abstract fun withConfig(config:

)

class UnstartedMockNode

Module Contents

installCordaService

(

serviceClass

)

Module Contents

password

permissions

)

createMockCordaService

(

serviceHub

serviceConstructor

(

AppServiceHub

)

ledger

(

notary

script

LedgerDSL

(

)

)

LedgerDSL

fun makeTestIdentityService(vararg identities:

)

fun testActor(owningLegalIdentity:

fun testContext(owningLegalIdentity:

)

Actor

)

transaction

(

notary

script

(

)

)

LedgerDSL

package net.corda.testing.services

Module Contents

class MockAttachmentStorage :

fun getAttachmentIdAndBytes(jar:

Module Contents

MockAttachmentStorage()

)

fun getLatestContractAttachments(contractClassName:

minContractVersion

)

fun hasAttachment(attachmentId:

)

)

fun importContractAttachment(contractClassNames:

uploader

filename

)

uploader

jar

attachmentId

signers

)

fun importContractAttachment(attachmentId:

contractAttachment

ContractAttachment

)

fun importOrGetAttachment(jar:

)

fun openAttachment(id:

)

fun queryAttachments(criteria:

sorting

)